using dnAnalytics.Nli.Acml;
/* ILapack.cs 
 * This provides our interface to LAPACK routines. 
 * Copyright (c) 2005, dnAnalytics. All rights reserved. 
 */

namespace dnAnalytics.Nli {
	/// <summary>
	/// An enumeration of the available LAPACK providers.
	/// </summary>
	public enum LapackProvider {
		/// <summary>
		/// Provider for AMD's ACML.
		/// </summary>
		Acml,

		/// <summary>
		/// Provider for AMD's ACML build using CVF (Compaq Visual Fortan). A seperate provider is needed
		/// because the version uses different export names than the other versions of ACML.
		/// </summary>
		AcmlCvf,

		/// <summary>
		/// Provider for the CLAPACK library.
		/// </summary>
		/// <remarks>ATLAS versions of the getrf, getri, getrs, potrf, potri, and potrs routines
		/// are used instead of the CLAPACK versions. ATLAS also provides the BLAS routines used by
		/// CLAPACK.</remarks>
		Clapack,

		/// <summary>
		/// Provider for INTEL's Math Kernel Libary.
		/// </summary>
		Mkl
	}

	/// <summary>
	/// The class provides access to the the various LAPACK providers.
	/// </summary>
	public class Lapack {
		private Lapack() {}

		/// <summary>
		/// The method returns an <see cref="ILapack"/> interface for the requested LAPACK provider.
		/// </summary>
		/// <param name="provider">The <see cref="LapackProvider"/> to return.</param>
		/// <returns>An <see cref="ILapack"/> interface for the requested LAPACK provider.</returns>
		public static ILapack Provider(LapackProvider provider) {
			switch (provider) {
				case LapackProvider.Acml:
					return Acml.Lapack.Instance;
				case LapackProvider.AcmlCvf:
					return LapackCvf.Instance;
				case LapackProvider.Clapack:
					return AtlasClapack.Lapack.Instance;
				case LapackProvider.Mkl:
					return Mkl.Lapack.Instance;
				default:
					return null;
			}
		}
	}

	/// <summary>
	/// Interface for LAPACK routines.
	/// </summary>
	public interface ILapack {
		/// <summary>
		/// Computes the least squares solution to an over-determined system of linear equations, A*X=B, or the minimum norm
		/// solution of an under-determined system, where A is a general rectangular matrix of full rank, using a QR or LQ factorization
		/// of A or underdetermined linear system with full rank matrix.
		/// </summary>
		/// <param name="trans">If <c>trans</c> == 'N': the linear system involves <paramref name="a"/>. If <c>trans</c> == 'T': the linear system involves <paramref name="a"/>'.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m</c> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n</c> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrix <paramref name="b"/>. <c>nrhs</c> &gt;=0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix. On exit, if <paramref name="m"/> >= <paramref name="n"/>, 
		/// <paramref name="a"/> is overwritten by details of its QR factorization as returned by Sgeqrf. Otherwise, <paramref name="a"/> is 
		/// overwritten by details of its LQ factorization as returned by Sgelqf.</param>
		/// <param name="lda">The leading dimension of <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b"> Dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>). On entry, the matrix <c>b</c> of right hand side vectors, stored columnwise. 
		/// b is <paramref name="m"/> by <paramref name="nrhs"/> if <paramref name="trans"/> == 'N', or <paramref name="n"/> by <paramref name="n"/> by <paramref name="nrhs"/>
		/// if <paramref name="trans"/> == 'T'. On exit, <c>b</c> is overwritten by the solution vectors, stored columnwise: 
		/// <list>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="n"/> to <paramref name="m"/>-1 in that column.</item>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &lt; <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &lt;<paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="m"/> to <paramref name="n"/>-1 in that column.</item>
		/// </list></param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sgels(char trans, int m, int n, int nrhs, float[] a, int lda, float[] b, int ldb);

		/// <summary>
		/// Computes the least squares solution to an over-determined system of linear equations, A*X=B, or the minimum norm
		/// solution of an under-determined system, where A is a general rectangular matrix of full rank, using a QR or LQ factorization
		/// of A or underdetermined linear system with full rank matrix.
		/// </summary>
		/// <param name="trans">If <c>trans</c> == 'N': the linear system involves <paramref name="a"/>. If <c>trans</c> == 'T': the linear system involves <paramref name="a"/>'.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m</c> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n</c> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrix <paramref name="b"/>. <c>nrhs</c> &gt;=0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix. On exit, if <paramref name="m"/> >= <paramref name="n"/>, 
		/// <paramref name="a"/> is overwritten by details of its QR factorization as returned by Sgeqrf. Otherwise, <paramref name="a"/> is 
		/// overwritten by details of its LQ factorization as returned by Sgelqf.</param>
		/// <param name="lda">The leading dimension of <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b"> Dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>). On entry, the matrix <c>b</c> of right hand side vectors, stored columnwise. 
		/// b is <paramref name="m"/> by <paramref name="nrhs"/> if <paramref name="trans"/> == 'N', or <paramref name="n"/> by <paramref name="n"/> by <paramref name="nrhs"/>
		/// if <paramref name="trans"/> == 'T'. On exit, <c>b</c> is overwritten by the solution vectors, stored columnwise: 
		/// <list>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="n"/> to <paramref name="m"/>-1 in that column.</item>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &lt; <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &lt;<paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="m"/> to <paramref name="n"/>-1 in that column.</item>
		/// </list></param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="work">Work array. On exit, <c>work[0]</c> equals the optimal length the work array should be.
		/// The length of <c>work</c> should be at least max( 1, MN + max( MN, <paramref name="nrhs"/> ) ). For optimal performance,
		/// The length of <c>work</c> should be at least max( 1, MN + max( MN, <paramref name="nrhs"/> )*NB ), where MN = min(<paramref name="m"/>,<paramref name="n"/>) and NB is the optimum block size.
		/// </param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sgels(char trans, int m, int n, int nrhs, float[] a, int lda, float[] b, int ldb, float[] work);

		/// <summary>
		/// <para>Computes the minimum norm solution to a real linear least squares problem:</para>
		/// <para>Minimize 2-norm(| B - A*X |)</para>
		/// <para>using the singular value decomposition (SVD) of A. A is an M by N matrix which may be rank-deficient.
		/// Several right hand side vectors B and solution vectors X can be handled in a single call. They are stored as the columns of the
		/// M by NRHS right hand side matrix B and the N by NRHS solution matrix X.
		/// The effective rank of A is determined by treating as zero those singular values which are less than rcond times the largest singular value.</para>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <paramref name="a"/>. On exit, the first min(<paramref name="m"/>,n) rows of <paramref name="a"/> 
		/// are overwritten with its right singular vectors, stored rowwise.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>. On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, <paramref name="b"/> is overwritten by the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X. If <paramref name="m"/> &gt;= <paramref name="n"/> and RANK = <paramref name="n"/>, the residual
		/// sum-of-squares for the solution in the i-th column is given	by the sum of squares of elements <paramref name="n"/>:<paramref name="m"/>-1 in that column.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,max(<paramref name="m"/>,<paramref name="n"/>)).</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>) The singular values of <paramref name="a"/> in decreasing order. The condition number of <paramref name="a"/> 
		/// in the 2-norm = <paramref name="s"/>[0]/<paramref name="s"/>[min(<paramref name="m"/>,<paramref name="n"/>)-1].</param>
		/// <param name="rank">The effective rank of A.</param>
		/// <returns> <list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the algorithm for computing the SVD failed to converge. i-th off-diagonal elements of an intermediate
		/// bidiagonal form did not converge to zero.</item>
		/// </list></returns>
		int Sgelss(int m, int n, int nrhs, float[] a, int lda, float[] b, int ldb, out float[] s, ref int rank);

		/// <summary>
		/// <para>Computes the minimum norm solution to a real linear least squares problem:</para>
		/// <para>Minimize 2-norm(| B - A*X |)</para>
		/// <para>using the singular value decomposition (SVD) of A. A is an M by N matrix which may be rank-deficient.
		/// Several right hand side vectors B and solution vectors X can be handled in a single call. They are stored as the columns of the
		/// M by NRHS right hand side matrix B and the N by NRHS solution matrix X.
		/// The effective rank of A is determined by treating as zero those singular values which are less than rcond times the largest singular value.</para>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <paramref name="a"/>. On exit, the first min(<paramref name="m"/>,n) rows of <paramref name="a"/> 
		/// are overwritten with its right singular vectors, stored rowwise.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>. On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, <paramref name="b"/> is overwritten by the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X. If <paramref name="m"/> &gt;= <paramref name="n"/> and RANK = <paramref name="n"/>, the residual
		/// sum-of-squares for the solution in the i-th column is given	by the sum of squares of elements <paramref name="n"/>:<paramref name="m"/>-1 in that column.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,max(<paramref name="m"/>,<paramref name="n"/>)).</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>) The singular values of <paramref name="a"/> in decreasing order. The condition number of <paramref name="a"/> 
		/// in the 2-norm = S[0]/S[min(<paramref name="m"/>,<paramref name="n"/>)-1].</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>. Singular values <paramref name="s"/>[i] &lt;= <c>rcond</c>*<paramref name="s"/>[0] are treated as zero.
		/// If <c>rcond</c> &lt; 0, machine precision is used instead.</param>
		/// <param name="rank">The effective rank of A, i.e., the number of singular values which are greater than <paramref name="rcond"/>*<paramref name="s"/>[0].</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.
		/// The length of <c>work</c> should be at least 3*min(<paramref name="m"/>,<paramref name="n"/>) + max( 2*min(<paramref name="m"/>,<paramref name="n"/>), max(<paramref name="m"/>,<paramref name="n"/>), <paramref name="nrhs"/> ).
		/// </param>
		/// <returns> <list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the algorithm for computing the SVD failed to converge. i-th off-diagonal elements of an intermediate
		/// bidiagonal form did not converge to zero.</item>
		/// </list></returns>
		int Sgelss(int m, int n, int nrhs, float[] a, int lda, float[] b, int ldb, out float[] s, float rcond, ref int rank, float[] work);

		/// <summary>
		/// <para>Computes the minimum-norm solution to a real linear least squares problem:</para>
		/// <para>minimize || A * X - B ||</para>
		/// <para>using a complete orthogonal factorization of A. A is an M by N
		/// matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be
		/// handled in a single call; they are stored as the columns of the M by NRHS right hand side matrix B 
		/// and the N by NRHS solution matrix X. The routine first computes a QR factorization with column pivoting:
		/// <code>
		/// A * P = Q * [ R00 R01 ]
		///             [ 0   R11 ]
		/// </code>
		/// with R11 defined as the largest leading submatrix whose estimated
		/// condition number is less than 1/RCOND. The order of R11, RANK,
		/// is the effective rank of A.</para>
		/// <para>Then, R22 is considered to be negligible, and R12 is annihilated
		/// by orthogonal transformations from the right, arriving at the complete orthogonal factorization:
		/// <code>
		/// A * P = Q * [ T00 0 ] * Z
		///             [ 0   0 ]
		/// </code>
		/// The minimum-norm solution is then
		/// <code>
		/// X = P * Z' [ inv(T00)*Q0'*B ]
		///            [       0        ]
		/// </code>
		/// where Q0 consists of the first RANK columns of Q.</para>
		/// This routine is basically identical to the original xGELSX except three differences:
		/// <list>
		/// <item>The call to the subroutine xGEQPF has been substituted by the
		/// the call to the subroutine xGEQP3. This subroutine is a Blas-3
		/// version of the QR factorization with column pivoting.</item>
		/// <item>Matrix B (the right hand side) is updated with Blas-3.</item>
		/// <item>The permutation of matrix B (the right hand side) is faster and more simple.</item>
		/// </list>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of
		/// columns of matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, <c>a</c> has been overwritten by details of its complete orthogonal factorization.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>)
		/// On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="jpvt">On entry, if <c>jpvt[i] != 0</c>, the i-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>P, otherwise column i is a free column.
		/// On exit, if <c>jpvt[i] = k</c>, then the i-th column of <paramref name="a"/>P
		/// was the k-th column of <paramref name="a"/>.</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>, which
		/// is defined as the order of the largest leading triangular
		/// submatrix R00 in the QR factorization with pivoting of <paramref name="a"/>,
		/// whose estimated condition number &lt; <c>1/rcond</c>.</param>
		/// <param name="rank"> The effective rank of <paramref name="a"/>, i.e., the order of the submatrix
		/// R00. This is the same as the order of the submatrix T00
		/// in the complete orthogonal factorization of <paramref name="a"/>.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sgelsy(int m, int n, int nrhs, float[] a, int lda, float[] b, int ldb, int[] jpvt, float rcond, ref int rank);

		/// <summary>
		/// <para>Computes the minimum-norm solution to a real linear least squares problem:</para>
		/// <para>minimize || A * X - B ||</para>
		/// <para>using a complete orthogonal factorization of A. A is an M by N
		/// matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be
		/// handled in a single call; they are stored as the columns of the M by NRHS right hand side matrix B 
		/// and the N by NRHS solution matrix X. The routine first computes a QR factorization with column pivoting:
		/// <code>
		/// A * P = Q * [ R00 R01 ]
		///             [ 0   R11 ]</code>
		/// with R11 defined as the largest leading submatrix whose estimated
		/// condition number is less than 1/RCOND. The order of R11, RANK,
		/// is the effective rank of A.</para>
		/// <para>Then, R22 is considered to be negligible, and R12 is annihilated
		/// by orthogonal transformations from the right, arriving at the complete orthogonal factorization:
		/// <code>
		/// A * P = Q * [ T00 0 ] * Z
		///             [ 0   0 ]</code>
		/// The minimum-norm solution is then
		/// <code>
		/// X = P * Z' [ inv(T00)*Q0'*B ]
		///            [        0       ]</code>
		/// where Q0 consists of the first RANK columns of Q.</para>
		/// This routine is basically identical to the original xGELSX except three differences:
		/// <list>
		/// <item>The call to the subroutine xGEQPF has been substituted by the
		/// the call to the subroutine xGEQP3. This subroutine is a Blas-3
		/// version of the QR factorization with column pivoting.</item>
		/// <item>Matrix B (the right hand side) is updated with Blas-3.</item>
		/// <item>The permutation of matrix B (the right hand side) is faster and more simple.</item>
		/// </list>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of
		/// columns of matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, <c>a</c> has been overwritten by details of its complete orthogonal factorization.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>)
		/// On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="jpvt">On entry, if <c>jpvt[i] != 0</c>, the i-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>P, otherwise column i is a free column.
		/// On exit, if <c>jpvt[i] = k</c>, then the i-th column of <paramref name="a"/>P
		/// was the k-th column of <paramref name="a"/>.</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>, which
		/// is defined as the order of the largest leading triangular
		/// submatrix R00 in the QR factorization with pivoting of <paramref name="a"/>,
		/// whose estimated condition number &lt; <c>1/rcond</c>.</param>
		/// <param name="rank"> The effective rank of <paramref name="a"/>, i.e., the order of the submatrix
		/// R00. This is the same as the order of the submatrix T00
		/// in the complete orthogonal factorization of <paramref name="a"/>.</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.
		/// The length of <c>work</c> should be at least max( MN+2*<paramref name="n"/>+NB*(<paramref name="n"/>+1), 2*MN+NB*<paramref name="nrhs"/> ) 
		/// where MN = min( <paramref name="m"/>, <paramref name="n"/> ) and NB is an upper bound on the blocksize returned by ILAENV
		/// for the routines SGEQP3, STZRZF, STZRQF, SORMQR, and SORMRZ.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sgelsy(int m, int n, int nrhs, float[] a, int lda, float[] b, int ldb, int[] jpvt, float rcond, ref int rank, float[] work);

		/// <summary>
		/// Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, the upper triangle of the array contains the
		/// min(<paramref name="m"/>,<paramref name="n"/>) by <paramref name="n"/> upper trapezoidal matrix R. The elements below
		/// the diagonal, together with the array <paramref name="tau"/>, represent the
		/// unitary matrix Q as a product of min(<paramref name="m"/>,<paramref name="n"/>) elementary
		/// reflectors.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="jpvt">Dimension <paramref name="n"/>.
		/// On entry, if <c>jpvt[j] != 0</c>, the j-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>*P (a leading column); if <c>jpvt[j] == 0</c>,
		/// the j-th column of <paramref name="a"/> is a free column.
		/// On exit, if <c>jpvt[j] == k</c>, then the j-th column of <paramref name="a"/>*P was the
		/// the k-th column of <paramref name="a"/>.</param>
		/// <param name="tau">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The scalar factors of the elementary reflectors.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sgeqp3(int m, int n, float[] a, int lda, int[] jpvt, float[] tau);

		/// <summary>
		/// Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, the upper triangle of the array contains the
		/// min(<paramref name="m"/>,<paramref name="n"/>) by <paramref name="n"/> upper trapezoidal matrix R. The elements below
		/// the diagonal, together with the array <paramref name="tau"/>, represent the
		/// unitary matrix Q as a product of min(<paramref name="m"/>,<paramref name="n"/>) elementary
		/// reflectors.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="jpvt">Dimension <paramref name="n"/>.
		/// On entry, if <c>jpvt[j] != 0</c>, the j-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>*P (a leading column); if <c>jpvt[j] == 0</c>,
		/// the j-th column of <paramref name="a"/> is a free column.
		/// On exit, if <c>jpvt[j] == k</c>, then the j-th column of <paramref name="a"/>*P was the
		/// the k-th column of <paramref name="a"/>.</param>
		/// <param name="tau">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The scalar factors of the elementary reflectors.</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use. 
		/// The length of <c>work</c> should be at least3*<paramref name="n"/>+1.
		/// For optimal performance the length of <c>work</c> should be at least2*<paramref name="n"/>+( <paramref name="n"/>+1 )*NB, where NB is the optimal blocksize.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sgeqp3(int m, int n, float[] a, int lda, int[] jpvt, float[] tau, float[] work);

		/// <summary>
		/// Computes the singular value decomposition (SVD) of a complex
		/// M by N matrix A, optionally computing the left and/or right singular
		/// vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V)
		/// where SIGMA is an M by N matrix which is zero except for its
		/// min(m,n) diagonal elements, U is an M by M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA
		/// are the singular values of A. They are real and non-negative, and
		/// are returned in descending order. The first min(m,n) columns of
		/// U and V are the left and right singular vectors of A.
		/// Note that the routine returns V**T, not V.
		/// </summary>
		/// <param name="jobu">
		/// Specifies options for computing all or part of the matrix <paramref name="u"/>:
		/// <list>
		/// <item> = '<paramref name="a"/>': all <paramref name="m"/> columns of <paramref name="u"/> are returned in array <paramref name="u"/>.</item>
		/// <item> = '<paramref name="s"/>': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are returned in the array <paramref name="u"/>.</item>
		/// <item> = 'O': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item> = '<paramref name="n"/>': no columns of <paramref name="u"/> (no left singular vectors) are computed. </item>
		/// </list>
		/// </param>
		/// <param name="jobvt">
		/// Specifies options for computing all or part of the matrix V**T:
		/// <list>
		/// <item>'<paramref name="a"/>': all <paramref name="n"/> rows of V**T are returned in the array <paramref name="vt"/>.</item>
		/// <item>'<paramref name="s"/>': the first min(m,n) rows of V**T (the right singular vectors) are returned in the array <paramref name="vt"/>.</item>
		/// <item>'O': the first min(m,n) rows of V**T (the right singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item>'<paramref name="n"/>': no rows of V**T (no right singular vectors) are computed.</item>
		/// </list>
		/// </param>
		/// <param name="m">The number of rows of the input matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the input matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit:<list>
		/// <item>if <paramref name="jobu"/> == 'O', <c>a</c> is overwritten with the first min(m,n) columns of <paramref name="u"/> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobvt"/> == 'O', <c>a</c> is overwritten with the first min(m,n)rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>if <paramref name="jobu"/> != 'O' and <paramref name="jobvt"/> != 'O', the contents of <c>a</c> are destroyed.</item>
		/// </list></param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The singular values of <paramref name="a"/>, sorted so that <c>s[i] &gt;= s[i+1]</c>.</param>
		/// <param name="u">Dimension <paramref name="ldu"/> by UCOL, <paramref name="ldu"/> by <paramref name="m"/> if <paramref name="jobu"/> = '<paramref name="a"/>', or <paramref name="ldu"/> by min(<paramref name="m"/>,<paramref name="n"/>) if <paramref name="jobu"/> = '<paramref name="s"/>'.
		/// <list>
		/// <item>If <paramref name="jobu"/> == '<paramref name="a"/>', <c>u</c> contains the <paramref name="m"/> by <paramref name="m"/> orthogonal matrix <c>u</c>.</item>
		/// <item>If <paramref name="jobu"/> == '<paramref name="s"/>', <c>u</c> contains the first min(m,n) columns of <c>u</c> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobu"/> == '<paramref name="n"/>' or 'O', <c>u</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldu">The leading dimension of the array <paramref name="u"/>. <c>ldu &gt;= 1</c>. If <paramref name="jobu"/> = '<paramref name="s"/>' or '<paramref name="a"/>', <c>ldu &gt;= <paramref name="m"/></c>.</param>
		/// <param name="vt">Dimension <paramref name="ldvt"/> by <paramref name="n"/>.
		/// <list>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="a"/>', <c>vt</c> contains the <paramref name="n"/> by <paramref name="n"/> orthogonal matrix V**T.</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="s"/>', <c>vt</c> contains the first min(m,n) rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="n"/>' or 'O', <c>vt</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldvt">The leading dimension of the array <paramref name="vt"/>. <c>ldvt &gt;= 1</c>. If <paramref name="jobvt"/> == '<paramref name="a"/>', 
		/// <c>ldvt &gt;= <paramref name="n"/></c>; if <paramref name="jobvt"/> == '<paramref name="s"/>', <c><paramref name="ldvt"/> &gt;= min(<paramref name="m"/>,<paramref name="n"/>)</c>.</param>
		/// <returns><list>
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: if SBDSQR did not converge, specifies how many
		/// superdiagonals of an intermediate bidiagonal form B
		/// did not converge to zero.</item>
		/// </list></returns>
		/// <remarks><paramref name="jobvt"/> and <paramref name="jobu"/> cannot both be 'O'.</remarks>
		int Sgesvd(char jobu, char jobvt, int m, int n, float[] a, int lda, float[] s, float[] u, int ldu, float[] vt, int ldvt);

		/// <summary>
		/// Computes the singular value decomposition (SVD) of a complex
		/// M by N matrix A, optionally computing the left and/or right singular
		/// vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V)
		/// where SIGMA is an M by N matrix which is zero except for its
		/// min(m,n) diagonal elements, U is an M by M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA
		/// are the singular values of A. They are real and non-negative, and
		/// are returned in descending order. The first min(m,n) columns of
		/// U and V are the left and right singular vectors of A.
		/// Note that the routine returns V**T, not V.
		/// </summary>
		/// <param name="jobu">
		/// Specifies options for computing all or part of the matrix <paramref name="u"/>:
		/// <list>
		/// <item> = '<paramref name="a"/>': all <paramref name="m"/> columns of <paramref name="u"/> are returned in array <paramref name="u"/>.</item>
		/// <item> = '<paramref name="s"/>': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are returned in the array <paramref name="u"/>.</item>
		/// <item> = 'O': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item> = '<paramref name="n"/>': no columns of <paramref name="u"/> (no left singular vectors) are computed. </item>
		/// </list>
		/// </param>
		/// <param name="jobvt">
		/// Specifies options for computing all or part of the matrix V**T:
		/// <list>
		/// <item>'<paramref name="a"/>': all <paramref name="n"/> rows of V**T are returned in the array <paramref name="vt"/>.</item>
		/// <item>'<paramref name="s"/>': the first min(m,n) rows of V**T (the right singular vectors) are returned in the array <paramref name="vt"/>.</item>
		/// <item>'O': the first min(m,n) rows of V**T (the right singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item>'<paramref name="n"/>': no rows of V**T (no right singular vectors) are computed.</item>
		/// </list>
		/// </param>
		/// <param name="m">The number of rows of the input matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the input matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit:<list>
		/// <item>if <paramref name="jobu"/> == 'O', <c>a</c> is overwritten with the first min(m,n) columns of <paramref name="u"/> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobvt"/> == 'O', <c>a</c> is overwritten with the first min(m,n)rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>if <paramref name="jobu"/> != 'O' and <paramref name="jobvt"/> != 'O', the contents of <c>a</c> are destroyed.</item>
		/// </list></param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The singular values of <paramref name="a"/>, sorted so that <c>s[i] &gt;= s[i+1]</c>.</param>
		/// <param name="u">Dimension <paramref name="ldu"/> by UCOL, <paramref name="ldu"/> by <paramref name="m"/> if <paramref name="jobu"/> = '<paramref name="a"/>', or <paramref name="ldu"/> by min(<paramref name="m"/>,<paramref name="n"/>) if <paramref name="jobu"/> = '<paramref name="s"/>'.
		/// <list>
		/// <item>If <paramref name="jobu"/> == '<paramref name="a"/>', <c>u</c> contains the <paramref name="m"/> by <paramref name="m"/> orthogonal matrix <c>u</c>.</item>
		/// <item>If <paramref name="jobu"/> == '<paramref name="s"/>', <c>u</c> contains the first min(m,n) columns of <c>u</c> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobu"/> == '<paramref name="n"/>' or 'O', <c>u</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldu">The leading dimension of the array <paramref name="u"/>. <c>ldu &gt;= 1</c>. If <paramref name="jobu"/> = '<paramref name="s"/>' or '<paramref name="a"/>', <c>ldu &gt;= <paramref name="m"/></c>.</param>
		/// <param name="vt">Dimension <paramref name="ldvt"/> by <paramref name="n"/>.
		/// <list>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="a"/>', <c>vt</c> contains the <paramref name="n"/> by <paramref name="n"/> orthogonal matrix V**T.</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="s"/>', <c>vt</c> contains the first min(m,n) rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="n"/>' or 'O', <c>vt</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldvt">The leading dimension of the array <paramref name="vt"/>. <c>ldvt &gt;= 1</c>. If <paramref name="jobvt"/> == '<paramref name="a"/>', 
		/// <c>ldvt &gt;= <paramref name="n"/></c>; if <paramref name="jobvt"/> == '<paramref name="s"/>', <c><paramref name="ldvt"/> &gt;= min(<paramref name="m"/>,<paramref name="n"/>)</c>.</param>
		/// <param name="work">Work array. The length of <c>work</c> should be at least max(3*min(<paramref name="m"/>,<paramref name="n"/>)+max(<paramref name="m"/>,<paramref name="n"/>),5*min(<paramref name="m"/>,<paramref name="n"/>)).
		/// On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use. 
		/// If the method returns a value greater than 0, <c>work[1:min(<paramref name="m"/>,<paramref name="n"/>)-1]</c> contains the unconverged superdiagonal elements of an upper bidiagonal
		/// matrix B whose diagonal is in <paramref name="s"/> (not necessarily sorted).
		/// B satisfies <paramref name="a"/> = <paramref name="u"/> * B * <paramref name="vt"/>, so it has the same singular
		/// values as <paramref name="a"/>, and singular vectors related by <paramref name="u"/> and <paramref name="vt"/>.</param>
		/// <returns><list>
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: if SBDSQR did not converge, specifies how many
		/// superdiagonals of an intermediate bidiagonal form B
		/// did not converge to zero.See the description of <paramref name="work"/>
		/// above for details.</item>
		/// </list></returns>
		/// <remarks><paramref name="jobvt"/> and <paramref name="jobu"/> cannot both be 'O'.</remarks>
		int Sgesvd(char jobu, char jobvt, int m, int n, float[] a, int lda, float[] s, float[] u, int ldu, float[] vt, int ldvt, float[] work);

		/// <summary>
		/// Computes an LU factorization of a general M by N matrix A
		/// using partial pivoting with row interchanges. 
		/// The factorization has the form A = P * L * U
		/// where P is a permutation matrix, L is lower triangular with unit
		/// diagonal elements (lower trapezoidal if m &gt; n), and U is upper
		/// triangular (upper trapezoidal if m &lt; n).
		/// This is the right-looking Level 3 BLAS version of the algorithm.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimensions <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/>-by-<paramref name="n"/> matrix to be factored.
		/// On exit, the factors L and U from the factorization
		/// A = P*L*U. The unit diagonal elements of L are not stored.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="ipiv">Dimension min(<paramref name="m"/>,<paramref name="n"/>).
		/// The pivot indices. for 0 &lt;= i &lt;= min(<paramref name="m"/>,<paramref name="n"/>), row i of the matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <returns>
		/// <list> 
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: U[i,i] is exactly zero. The factorization has been completed, but the factor U is exactly
		///	singular, and division by zero will occur if it is used
		/// to solve a system of equations.</item>
		/// </list></returns>
		int Sgetrf(int m, int n, float[] a, int lda, out int[] ipiv);

		/// <summary>
		/// Computes the inverse of a matrix using the LU factorization
		/// computed by SGETRF. This method inverts U and then computes 
		/// inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
		/// </summary>
		/// <param name="n"> The order of the matrix <parmaref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <parmaref name="lda"/> by <parmaref name="n"/>. On entry, the factors L and U from the factorization
		/// A = P*L*U as computed by SGETRF.
		/// On exit, the inverse of the original matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <parmaref name="a"/>. <c>lda</c> &gt;= max(1,<parmaref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from SGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value</item>
		/// <item>&gt; 0: U[i,i] is exactly zero; the matrix is
		/// singular and its inverse could not be computed.</item>
		/// </list></returns>
		int Sgetri(int n, float[] a, int lda, int[] ipiv);

		/// <summary>
		/// Computes the inverse of a matrix using the LU factorization
		/// computed by SGETRF. This method inverts U and then computes 
		/// inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
		/// </summary>
		/// <param name="n"> The order of the matrix <parmaref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <parmaref name="lda"/> by <parmaref name="n"/>. On entry, the factors L and U from the factorization
		/// A = P*L*U as computed by SGETRF.
		/// On exit, the inverse of the original matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <parmaref name="a"/>. <c>lda</c> &gt;= max(1,<parmaref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from SGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <param name="work">Work array. The length of <c>work</c> should be at least <paramref name="n"/>*NB,
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value</item>
		/// <item>&gt; 0: U[i,i] is exactly zero; the matrix is
		/// singular and its inverse could not be computed.</item>
		/// </list></returns>
		int Sgetri(int n, float[] a, int lda, int[] ipiv, float[] work);

		/// <summary>
		/// Solves a system of linear equations A * X = B or A' * X = B
		/// with a general N by N matrix A using the LU factorization computed by SGETRF.
		/// </summary>
		/// <param name="trans"> Specifies the form of the system of equations:
		/// <list>
		/// <item>'N': A * X = B (No transpose)</item>
		/// <item>'T': A'* X = B (Transpose)</item>
		/// <item>'C': A'* X = B (Conjugate transpose = Transpose)</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns
		/// of the matrix <paramref name="b"/>. <c>nrhs &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by SGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from SGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <param name="b">Dimension <parmaref name="ldb"/> by <parmaref name="nrhs"/>.
		/// On entry, the right hand side matrix <c>b</c>.
		/// On exit, the solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sgetrs(char trans, int n, int nrhs, float[] a, int lda, int[] ipiv, float[] b, int ldb);

		/// <summary>
		/// Generates an M by N real matrix Q with orthonormal columns,
		/// which is defined as the first N columns of a product of K elementary
		/// reflectors of order M: <code>Q = H(0) H(1) . . . H(k-1)</code>
		/// as returned by SGEQRF.
		/// </summary>
		/// <param name="m">The number of rows of the matrix Q. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix Q. <c>m &gt;= n &gt;= 0</c></param>
		/// <param name="k">The number of elementary reflectors whose product defines the matrix Q. <c>n &gt;= k &gt;= 0</c>.</param>
		/// <param name="a">Dimension LDA by N.
		/// On entry, the i-th column must contain the vector which defines the elementary reflector H(0), for i = 0,2,...,k-1, as
		/// returned by SGEQRF in the first k columns of its array argument <c>a</c>.
		/// On exit, the <parmaref name="m"/> by <parmaref name="n"/> matrix Q.</param>
		/// <param name="lda">The first dimension of the array <parmaref name="a"/> . <c>lda</c> &gt;= max(1,<parmaref name="m"/>).</param>
		/// <param name="tau">Dimension K. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by SGEQRF.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sorgqr(int m, int n, int k, float[] a, int lda, float[] tau);

		/// <summary>
		/// Generates an M by N real matrix Q with orthonormal columns,
		/// which is defined as the first N columns of a product of K elementary
		/// reflectors of order M: <code>Q = H(0) H(1) . . . H(k-1)</code>
		/// as returned by SGEQRF.
		/// </summary>
		/// <param name="m">The number of rows of the matrix Q. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix Q. <c>m &gt;= n &gt;= 0</c></param>
		/// <param name="k">The number of elementary reflectors whose product defines the matrix Q. <c>n &gt;= k &gt;= 0</c>.</param>
		/// <param name="a">Dimension LDA by N.
		/// On entry, the i-th column must contain the vector which defines the elementary reflector H(0), for i = 0,2,...,k-1, as
		/// returned by SGEQRF in the first k columns of its array argument <c>a</c>.
		/// On exit, the <parmaref name="m"/> by <parmaref name="n"/> matrix Q.</param>
		/// <param name="lda">The first dimension of the array <parmaref name="a"/> . <c>lda</c> &gt;= max(1,<parmaref name="m"/>).</param>
		/// <param name="tau">Dimension K. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by SGEQRF.</param>
		/// <param name="work">Work array. The length of <c>work</c> should be at least <paramref name="n"/>*NB,
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <c>work[0]</c> returns the optimal length of <c>work</c> to use.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sorgqr(int m, int n, int k, float[] a, int lda, float[] tau, float[] work);

		/// <summary>
		/// <para>Overwrites the general real M-by-N matrix C with
		/// <pre>             SIDE = 'L'    SIDE = 'R'</pre>
		/// <pre>TRANS = 'N':   Q * C         C * Q</pre>
		/// <pre>TRANS = 'T':   Q**T * C      C * Q**T</pre>																			
		/// where Q is a real orthogonal matrix defined as the product of k elementary reflectors
		/// Q = H(0) H(1) . . . H(k-1) as returned by SGEQRF. Q is of order M if 
		/// SIDE == 'L' and of order N if SIDE == 'R'.</para>
		/// </summary>
		/// <param name="side"><list>
		/// <item>'L': apply Q or Q**T from the Left.</item>
		/// <item>'R': apply Q or Q**T from the Right.</item>
		/// </list></param>
		/// <param name="trans"><list>
		/// <item>'N': No transpose, apply Q;</item>
		/// <item>'T': Transpose, apply Q**T.</item>
		/// </list></param>
		/// <param name="m">The number of rows of the matrix <paramref name="c"/>. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="c"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="k"> The number of elementary reflectors whose product defines the matrix Q.
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="m"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// <item>if <paramref name="side"/> == 'R', <paramref name="n"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// </list></param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="k"/>.
		/// The i-th column must contain the vector which defines the
		/// elementary reflector H(i), for i = 0,2,...,<paramref name="k"/>-1, as returned by
		///	SGEQRF in the first <paramref name="k"/> columns of its array argument <paramref name="a"/>.
		///	<paramref name="a"/> is modified by the routine but restored on exit.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/> .
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <c>lda</c> &gt;= max(1,<paramref name="m"/>).</item>
		/// <item>if <paramref name="side"/> == 'R', <c>lda</c> &gt;= max(1,<paramref name="n"/>).</item>
		/// </list></param>
		/// <param name="tau">Dimension <paramref name="k"/>. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by SGEQRF.</param>
		/// <param name="c">dimension <paramref name="ldc"/> by <paramref name="n"/>. 
		/// On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>c</c>.
		/// On exit, <c>c</c> is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.</param>
		/// <param name="ldc">The leading dimension of the array <paramref name="c"/>.<c>ldc</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sormqr(char side, char trans, int m, int n, int k, float[] a, int lda, float[] tau, float[] c, int ldc);

		/// <summary>
		/// <para>Overwrites the general real M-by-N matrix C with
		/// <pre>             SIDE = 'L'    SIDE = 'R'</pre>
		/// <pre>TRANS = 'N':   Q * C         C * Q</pre>
		/// <pre>TRANS = 'T':   Q**T * C      C * Q**T</pre>																				
		/// where Q is a real orthogonal matrix defined as the product of k elementary reflectors
		/// Q = H(0) H(1) . . . H(k-1) as returned by SGEQRF. Q is of order M if 
		/// SIDE == 'L' and of order N if SIDE == 'R'.</para>para>
		/// </summary>
		/// <param name="side"><list>
		/// <item>'L': apply Q or Q**T from the Left.</item>
		/// <item>'R': apply Q or Q**T from the Right.</item>
		/// </list></param>
		/// <param name="trans"><list>
		/// <item>'N': No transpose, apply Q;</item>
		/// <item>'T': Transpose, apply Q**T.</item>
		/// </list></param>
		/// <param name="m">The number of rows of the matrix <paramref name="c"/>. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="c"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="k"> The number of elementary reflectors whose product defines the matrix Q.
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="m"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// <item>If <paramref name="side"/> == 'R', <paramref name="n"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// </list></param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="k"/>.
		/// The i-th column must contain the vector which defines the
		/// elementary reflector H(i), for i = 0,2,...,<paramref name="k"/>-1, as returned by
		///	SGEQRF in the first <paramref name="k"/> columns of its array argument <paramref name="a"/>.
		///	<paramref name="a"/> is modified by the routine but restored on exit.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/> .
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <c>lda</c> &gt;= max(1,<paramref name="m"/>).</item>
		/// <item>If <paramref name="side"/> == 'R', <c>lda</c> &gt;= max(1,<paramref name="n"/>).</item>
		/// </list></param>
		/// <param name="tau">Dimension <paramref name="k"/>. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by SGEQRF.</param>
		/// <param name="c">dimension <paramref name="ldc"/> by <paramref name="n"/>. 
		/// On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>c</c>.
		/// On exit, <c>c</c> is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.</param>
		/// <param name="ldc">The leading dimension of the array <paramref name="c"/>.<c>ldc</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="work">Work array. The length of <c>work</c> should be:
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="n"/> * NB.</item>
		/// <item>if <paramref name="side"/> == 'R', <paramref name="m"/> * NB.</item>
		/// </list>
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <c>work[0]</c> returns the optimal length of <c>work</c> to use.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sormqr(char side, char trans, int m, int n, int k, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);

		/// <summary>
		/// Computes the Cholesky factorization of a real symmetric
		/// positive definite matrix A.
		/// The factorization has the form 
		/// <code>
		/// A = U**T * U, if UPLO == 'U' 
		/// A = L * L**T, if UPLO == 'L'
		/// </code>
		/// where U is an upper triangular matrix and L is lower triangular.
		/// This is the block version of the algorithm, calling Level 3 BLAS.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// On entry, the symmetric matrix <c>a</c>. 
		/// If <paramref name="uplo"/> == 'U', the leading <paramref name="n"/> by <paramref name="n"/> upper triangular part of <c>a</c>
		/// contains the upper triangular part of the matrix <c>a</c>, and the strictly lower triangular part of <c>a</c> is not referenced.
		/// If <paramref name="uplo"/> == 'L', the leading <paramref name="n"/> by <paramref name="n"/> lower triangular part of <c>a</c>
		/// contains the lower triangular part of the matrix <c>a</c>, and the strictly upper triangular part of <c>a</c> is not referenced.
		/// On exit, the factor U or L from the Cholesky factorization <c>A = U**T*U or A = L*L**T</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the leading minor of order i is not positive definite, and the factorization could not be completed.</item>
		/// </list></returns>
		int Spotrf(char uplo, int n, float[] a, int lda);

		/// <summary>
		/// Computes the inverse of a real symmetric positive definite
		/// matrix A using the Cholesky factorization A = U**T*U or A = L*L**T
		/// computed by SPOTRF.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// On entry, the triangular factor U or L from the Cholesky
		/// factorization A = U**T*U or A = L*L**T, as computed by SPOTRF.
		/// On exit, the upper or lower triangle of the (symmetric) inverse of <c>a</c>, 
		/// overwriting the input factor U or L.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the [i,i] element of the factor U or L is zero, and the inverse could not be computed.</item>
		/// </list></returns>
		int Spotri(char uplo, int n, float[] a, int lda);

		/// <summary>
		/// Solves a system of linear equations A*X = B with a symmetric
		/// positive definite matrix A using the Cholesky factorization
		/// <code>A = U**T*U or A = L*L**T</code> computed by SPOTRF.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns
		/// of the matrix <paramref name="b"/>. <c>nrhs &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The triangular factor U or L from the Cholesky factorization
		/// A = U**T*U or A = L*L**T, as computed by SPOTRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>.
		/// On entry, the right hand side matrix <c>b</c>.
		/// On exit, the solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Spotrs(char uplo, int n, int nrhs, float[] a, int lda, float[] b, int ldb);

		/// <summary>
		/// Computes the least squares solution to an over-determined system of linear equations, A*X=B, or the minimum norm
		/// solution of an under-determined system, where A is a general rectangular matrix of full rank, using a QR or LQ factorization
		/// of A or underdetermined linear system with full rank matrix.
		/// </summary>
		/// <param name="trans">If <c>trans</c> == 'N': the linear system involves <paramref name="a"/>. If <c>trans</c> == 'T': the linear system involves <paramref name="a"/>'.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m</c> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n</c> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrix <paramref name="b"/>. <c>nrhs</c> &gt;=0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix. On exit, if <paramref name="m"/> >= <paramref name="n"/>, 
		/// <paramref name="a"/> is overwritten by details of its QR factorization as returned by Sgeqrf. Otherwise, <paramref name="a"/> is 
		/// overwritten by details of its LQ factorization as returned by Sgelqf.</param>
		/// <param name="lda">The leading dimension of <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b"> Dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>). On entry, the matrix <c>b</c> of right hand side vectors, stored columnwise. 
		/// b is <paramref name="m"/> by <paramref name="nrhs"/> if <paramref name="trans"/> == 'N', or <paramref name="n"/> by <paramref name="n"/> by <paramref name="nrhs"/>
		/// if <paramref name="trans"/> == 'T'. On exit, <c>b</c> is overwritten by the solution vectors, stored columnwise: 
		/// <list>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="n"/> to <paramref name="m"/>-1 in that column.</item>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &lt; <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &lt;<paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="m"/> to <paramref name="n"/>-1 in that column.</item>
		/// </list></param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dgels(char trans, int m, int n, int nrhs, double[] a, int lda, double[] b, int ldb);

		/// <summary>
		/// Computes the least squares solution to an over-determined system of linear equations, A*X=B, or the minimum norm
		/// solution of an under-determined system, where A is a general rectangular matrix of full rank, using a QR or LQ factorization
		/// of A or underdetermined linear system with full rank matrix.
		/// </summary>
		/// <param name="trans">If <c>trans</c> == 'N': the linear system involves <paramref name="a"/>. If <c>trans</c> == 'T': the linear system involves <paramref name="a"/>'.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m</c> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n</c> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrix <paramref name="b"/>. <c>nrhs</c> &gt;=0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix. On exit, if <paramref name="m"/> >= <paramref name="n"/>, 
		/// <paramref name="a"/> is overwritten by details of its QR factorization as returned by Sgeqrf. Otherwise, <paramref name="a"/> is 
		/// overwritten by details of its LQ factorization as returned by Sgelqf.</param>
		/// <param name="lda">The leading dimension of <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b"> Dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>). On entry, the matrix <c>b</c> of right hand side vectors, stored columnwise. 
		/// b is <paramref name="m"/> by <paramref name="nrhs"/> if <paramref name="trans"/> == 'N', or <paramref name="n"/> by <paramref name="n"/> by <paramref name="nrhs"/>
		/// if <paramref name="trans"/> == 'T'. On exit, <c>b</c> is overwritten by the solution vectors, stored columnwise: 
		/// <list>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="n"/> to <paramref name="m"/>-1 in that column.</item>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &lt; <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &lt;<paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="m"/> to <paramref name="n"/>-1 in that column.</item>
		/// </list></param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="work">Work array. On exit, <c>work[0]</c> equals the optimal length the work array should be.
		/// The length of <c>work</c> should be at least max( 1, MN + max( MN, <paramref name="nrhs"/> ) ). For optimal performance,
		/// The length of <c>work</c> should be at least max( 1, MN + max( MN, <paramref name="nrhs"/> )*NB ), where MN = min(<paramref name="m"/>,<paramref name="n"/>) and NB is the optimum block size.
		/// </param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dgels(char trans, int m, int n, int nrhs, double[] a, int lda, double[] b, int ldb, double[] work);

		/// <summary>
		/// <para>Computes the minimum norm solution to a real linear least squares problem:</para>
		/// <para>Minimize 2-norm(| B - A*X |)</para>
		/// <para>using the singular value decomposition (SVD) of A. A is an M by N matrix which may be rank-deficient.
		/// Several right hand side vectors B and solution vectors X can be handled in a single call. They are stored as the columns of the
		/// M by NRHS right hand side matrix B and the N by NRHS solution matrix X.
		/// The effective rank of A is determined by treating as zero those singular values which are less than rcond times the largest singular value.</para>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <paramref name="a"/>. On exit, the first min(<paramref name="m"/>,n) rows of <paramref name="a"/> 
		/// are overwritten with its right singular vectors, stored rowwise.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>. On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, <paramref name="b"/> is overwritten by the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X. If <paramref name="m"/> &gt;= <paramref name="n"/> and RANK = <paramref name="n"/>, the residual
		/// sum-of-squares for the solution in the i-th column is given	by the sum of squares of elements <paramref name="n"/>:<paramref name="m"/>-1 in that column.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,max(<paramref name="m"/>,<paramref name="n"/>)).</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>) The singular values of <paramref name="a"/> in decreasing order. The condition number of <paramref name="a"/> 
		/// in the 2-norm = <paramref name="s"/>[0]/<paramref name="s"/>[min(<paramref name="m"/>,<paramref name="n"/>)-1].</param>
		/// <param name="rank">The effective rank of A.</param>
		/// <returns> <list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the algorithm for computing the SVD failed to converge. i-th off-diagonal elements of an intermediate
		/// bidiagonal form did not converge to zero.</item>
		/// </list></returns>
		int Dgelss(int m, int n, int nrhs, double[] a, int lda, double[] b, int ldb, out double[] s, ref int rank);

		/// <summary>
		/// <para>Computes the minimum norm solution to a real linear least squares problem:</para>
		/// <para>Minimize 2-norm(| B - A*X |)</para>
		/// <para>using the singular value decomposition (SVD) of A. A is an M by N matrix which may be rank-deficient.
		/// Several right hand side vectors B and solution vectors X can be handled in a single call. They are stored as the columns of the
		/// M by NRHS right hand side matrix B and the N by NRHS solution matrix X.
		/// The effective rank of A is determined by treating as zero those singular values which are less than rcond times the largest singular value.</para>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <paramref name="a"/>. On exit, the first min(<paramref name="m"/>,n) rows of <paramref name="a"/> 
		/// are overwritten with its right singular vectors, stored rowwise.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>. On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, <paramref name="b"/> is overwritten by the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X. If <paramref name="m"/> &gt;= <paramref name="n"/> and RANK = <paramref name="n"/>, the residual
		/// sum-of-squares for the solution in the i-th column is given	by the sum of squares of elements <paramref name="n"/>:<paramref name="m"/>-1 in that column.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,max(<paramref name="m"/>,<paramref name="n"/>)).</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>) The singular values of <paramref name="a"/> in decreasing order. The condition number of <paramref name="a"/> 
		/// in the 2-norm = S[0]/S[min(<paramref name="m"/>,<paramref name="n"/>)-1].</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>. Singular values <paramref name="s"/>[i] &lt;= <c>rcond</c>*<paramref name="s"/>[0] are treated as zero.
		/// If <c>rcond</c> &lt; 0, machine precision is used instead.</param>
		/// <param name="rank">The effective rank of A, i.e., the number of singular values which are greater than <paramref name="rcond"/>*<paramref name="s"/>[0].</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.
		/// The length of <c>work</c> should be at least 3*min(<paramref name="m"/>,<paramref name="n"/>) + max( 2*min(<paramref name="m"/>,<paramref name="n"/>), max(<paramref name="m"/>,<paramref name="n"/>), <paramref name="nrhs"/> ).
		/// </param>
		/// <returns> <list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the algorithm for computing the SVD failed to converge. i-th off-diagonal elements of an intermediate
		/// bidiagonal form did not converge to zero.</item>
		/// </list></returns>
		int Dgelss(int m, int n, int nrhs, double[] a, int lda, double[] b, int ldb, out double[] s, double rcond, ref int rank, double[] work);

		/// <summary>
		/// <para>Computes the minimum-norm solution to a real linear least squares problem:</para>
		/// <para>minimize || A * X - B ||</para>
		/// <para>using a complete orthogonal factorization of A. A is an M by N
		/// matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be
		/// handled in a single call; they are stored as the columns of the M by NRHS right hand side matrix B 
		/// and the N by NRHS solution matrix X. The routine first computes a QR factorization with column pivoting:
		/// <code>
		/// A * P = Q * [ R00 R01 ]
		///             [ 0   R11 ]
		/// </code>
		/// with R11 defined as the largest leading submatrix whose estimated
		/// condition number is less than 1/RCOND. The order of R11, RANK,
		/// is the effective rank of A.</para>
		/// <para>Then, R22 is considered to be negligible, and R12 is annihilated
		/// by orthogonal transformations from the right, arriving at the complete orthogonal factorization:
		/// <code>
		/// A * P = Q * [ T00 0 ] * Z
		///             [ 0   0 ]
		/// </code>
		/// The minimum-norm solution is then
		/// <code>
		/// X = P * Z' [ inv(T00)*Q0'*B ]
		///            [        0       ]
		/// </code>
		/// where Q0 consists of the first RANK columns of Q.</para>
		/// This routine is basically identical to the original xGELSX except three differences:
		/// <list>
		/// <item>The call to the subroutine xGEQPF has been substituted by the
		/// the call to the subroutine xGEQP3. This subroutine is a Blas-3
		/// version of the QR factorization with column pivoting.</item>
		/// <item>Matrix B (the right hand side) is updated with Blas-3.</item>
		/// <item>The permutation of matrix B (the right hand side) is faster and more simple.</item>
		/// </list>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of
		/// columns of matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, <c>a</c> has been overwritten by details of its complete orthogonal factorization.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>)
		/// On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="jpvt">On entry, if <c>jpvt[i] != 0</c>, the i-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>P, otherwise column i is a free column.
		/// On exit, if <c>jpvt[i] = k</c>, then the i-th column of <paramref name="a"/>P
		/// was the k-th column of <paramref name="a"/>.</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>, which
		/// is defined as the order of the largest leading triangular
		/// submatrix R00 in the QR factorization with pivoting of <paramref name="a"/>,
		/// whose estimated condition number &lt; <c>1/rcond</c>.</param>
		/// <param name="rank"> The effective rank of <paramref name="a"/>, i.e., the order of the submatrix
		/// R00. This is the same as the order of the submatrix T00
		/// in the complete orthogonal factorization of <paramref name="a"/>.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dgelsy(int m, int n, int nrhs, double[] a, int lda, double[] b, int ldb, int[] jpvt, double rcond, ref int rank);

		/// <summary>
		/// <para>Computes the minimum-norm solution to a real linear least squares problem:</para>
		/// <para>minimize || A * X - B ||</para>
		/// <para>using a complete orthogonal factorization of A. A is an M by N
		/// matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be
		/// handled in a single call; they are stored as the columns of the M by NRHS right hand side matrix B 
		/// and the N by NRHS solution matrix X. The routine first computes a QR factorization with column pivoting:
		/// <code>
		/// A * P = Q * [ R00 R01 ]
		///             [ 0   R11 ]
		/// </code>
		/// with R11 defined as the largest leading submatrix whose estimated
		/// condition number is less than 1/RCOND. The order of R11, RANK,
		/// is the effective rank of A.</para>
		/// <para>Then, R22 is considered to be negligible, and R12 is annihilated
		/// by orthogonal transformations from the right, arriving at the complete orthogonal factorization:
		/// <code>
		/// A * P = Q * [ T00 0 ] * Z
		///             [ 0   0 ]
		/// </code>
		/// The minimum-norm solution is then
		/// <code>
		/// X = P * Z' [ inv(T00)*Q0'*B ]
		///            [        0       ]
		/// </code>
		/// where Q0 consists of the first RANK columns of Q.</para>
		/// This routine is basically identical to the original xGELSX except three differences:
		/// <list>
		/// <item>The call to the subroutine xGEQPF has been substituted by the
		/// the call to the subroutine xGEQP3. This subroutine is a Blas-3
		/// version of the QR factorization with column pivoting.</item>
		/// <item>Matrix B (the right hand side) is updated with Blas-3.</item>
		/// <item>The permutation of matrix B (the right hand side) is faster and more simple.</item>
		/// </list>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of
		/// columns of matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, <c>a</c> has been overwritten by details of its complete orthogonal factorization.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>)
		/// On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="jpvt">On entry, if <c>jpvt[i] != 0</c>, the i-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>P, otherwise column i is a free column.
		/// On exit, if <c>jpvt[i] = k</c>, then the i-th column of <paramref name="a"/>P
		/// was the k-th column of <paramref name="a"/>.</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>, which
		/// is defined as the order of the largest leading triangular
		/// submatrix R00 in the QR factorization with pivoting of <paramref name="a"/>,
		/// whose estimated condition number &lt; <c>1/rcond</c>.</param>
		/// <param name="rank"> The effective rank of <paramref name="a"/>, i.e., the order of the submatrix
		/// R00. This is the same as the order of the submatrix T00
		/// in the complete orthogonal factorization of <paramref name="a"/>.</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.
		/// The length of <c>work</c> should be at least max( MN+2*<paramref name="n"/>+NB*(<paramref name="n"/>+1), 2*MN+NB*<paramref name="nrhs"/> ) 
		/// where MN = min( <paramref name="m"/>, <paramref name="n"/> ) and NB is an upper bound on the blocksize returned by ILAENV
		/// for the routines DGEQP3, DTZRZF, DTZRQF, DORMQR, and DORMRZ.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dgelsy(int m, int n, int nrhs, double[] a, int lda, double[] b, int ldb, int[] jpvt, double rcond, ref int rank, double[] work);

		/// <summary>
		/// Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, the upper triangle of the array contains the
		/// min(<paramref name="m"/>,<paramref name="n"/>) by <paramref name="n"/> upper trapezoidal matrix R. The elements below
		/// the diagonal, together with the array <paramref name="tau"/>, represent the
		/// unitary matrix Q as a product of min(<paramref name="m"/>,<paramref name="n"/>) elementary
		/// reflectors.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="jpvt">Dimension <paramref name="n"/>.
		/// On entry, if <c>jpvt[j] != 0</c>, the j-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>*P (a leading column); if <c>jpvt[j] == 0</c>,
		/// the j-th column of <paramref name="a"/> is a free column.
		/// On exit, if <c>jpvt[j] == k</c>, then the j-th column of <paramref name="a"/>*P was the
		/// the k-th column of <paramref name="a"/>.</param>
		/// <param name="tau">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The scalar factors of the elementary reflectors.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dgeqp3(int m, int n, double[] a, int lda, int[] jpvt, double[] tau);

		/// <summary>
		/// Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, the upper triangle of the array contains the
		/// min(<paramref name="m"/>,<paramref name="n"/>) by <paramref name="n"/> upper trapezoidal matrix R. The elements below
		/// the diagonal, together with the array <paramref name="tau"/>, represent the
		/// unitary matrix Q as a product of min(<paramref name="m"/>,<paramref name="n"/>) elementary
		/// reflectors.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="jpvt">Dimension <paramref name="n"/>.
		/// On entry, if <c>jpvt[j] != 0</c>, the j-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>*P (a leading column); if <c>jpvt[j] == 0</c>,
		/// the j-th column of <paramref name="a"/> is a free column.
		/// On exit, if <c>jpvt[j] == k</c>, then the j-th column of <paramref name="a"/>*P was the
		/// the k-th column of <paramref name="a"/>.</param>
		/// <param name="tau">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The scalar factors of the elementary reflectors.</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use. 
		/// The length of <c>work</c> should be at least3*<paramref name="n"/>+1.
		/// For optimal performance the length of <c>work</c> should be at least2*<paramref name="n"/>+( <paramref name="n"/>+1 )*NB, where NB is the optimal blocksize.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dgeqp3(int m, int n, double[] a, int lda, int[] jpvt, double[] tau, double[] work);

		/// <summary>
		/// Computes the singular value decomposition (SVD) of a complex
		/// M by N matrix A, optionally computing the left and/or right singular
		/// vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V)
		/// where SIGMA is an M by N matrix which is zero except for its
		/// min(m,n) diagonal elements, U is an M by M unitary matrix, and	V is an N-by-N unitary matrix. The diagonal elements of SIGMA
		/// are the singular values of A. They are real and non-negative, and
		/// are returned in descending order. The first min(m,n) columns of
		/// U and V are the left and right singular vectors of A.
		/// Note that the routine returns V**T, not V.
		/// </summary>
		/// <param name="jobu">
		/// Specifies options for computing all or part of the matrix <paramref name="u"/>:
		/// <list>
		/// <item> = '<paramref name="a"/>': all <paramref name="m"/> columns of <paramref name="u"/> are returned in array <paramref name="u"/>.</item>
		/// <item> = '<paramref name="s"/>': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are returned in the array <paramref name="u"/>.</item>
		/// <item> = 'O': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item> = '<paramref name="n"/>': no columns of <paramref name="u"/> (no left singular vectors) are computed. </item>
		/// </list>
		/// </param>
		/// <param name="jobvt">
		/// Specifies options for computing all or part of the matrix V**T:
		/// <list>
		/// <item>'<paramref name="a"/>': all <paramref name="n"/> rows of V**T are returned in the array <paramref name="vt"/>.</item>
		/// <item>'<paramref name="s"/>': the first min(m,n) rows of V**T (the right singular vectors) are returned in the array <paramref name="vt"/>.</item>
		/// <item>'O': the first min(m,n) rows of V**T (the right singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item>'<paramref name="n"/>': no rows of V**T (no right singular vectors) are computed.</item>
		/// </list>
		/// </param>
		/// <param name="m">The number of rows of the input matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the input matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit:<list>
		/// <item>if <paramref name="jobu"/> == 'O', <c>a</c> is overwritten with the first min(m,n) columns of <paramref name="u"/> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobvt"/> == 'O', <c>a</c> is overwritten with the first min(m,n)rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>if <paramref name="jobu"/> != 'O' and <paramref name="jobvt"/> != 'O', the contents of <c>a</c> are destroyed.</item>
		/// </list></param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The singular values of <paramref name="a"/>, sorted so that <c>s[i] &gt;= s[i+1]</c>.</param>
		/// <param name="u">Dimension <paramref name="ldu"/> by UCOL, <paramref name="ldu"/> by <paramref name="m"/> if <paramref name="jobu"/> = '<paramref name="a"/>', or <paramref name="ldu"/> by min(<paramref name="m"/>,<paramref name="n"/>) if <paramref name="jobu"/> = '<paramref name="s"/>'.
		/// <list>
		/// <item>If <paramref name="jobu"/> == '<paramref name="a"/>', <c>u</c> contains the <paramref name="m"/> by <paramref name="m"/> orthogonal matrix <c>u</c>.</item>
		/// <item>If <paramref name="jobu"/> == '<paramref name="s"/>', <c>u</c> contains the first min(m,n) columns of <c>u</c> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobu"/> == '<paramref name="n"/>' or 'O', <c>u</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldu">The leading dimension of the array <paramref name="u"/>. <c>ldu &gt;= 1</c>. If <paramref name="jobu"/> = '<paramref name="s"/>' or '<paramref name="a"/>', <c>ldu &gt;= <paramref name="m"/></c>.</param>
		/// <param name="vt">Dimension <paramref name="ldvt"/> by <paramref name="n"/>.
		/// <list>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="a"/>', <c>vt</c> contains the <paramref name="n"/> by <paramref name="n"/> orthogonal matrix V**T.</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="s"/>', <c>vt</c> contains the first min(m,n) rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="n"/>' or 'O', <c>vt</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldvt">The leading dimension of the array <paramref name="vt"/>. <c>ldvt &gt;= 1</c>. If <paramref name="jobvt"/> == '<paramref name="a"/>', 
		/// <c>ldvt &gt;= <paramref name="n"/></c>; if <paramref name="jobvt"/> == '<paramref name="s"/>', <c><paramref name="ldvt"/> &gt;= min(<paramref name="m"/>,<paramref name="n"/>)</c>.</param>
		/// <returns><list>
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: if DBDSQR did not converge, specifies how many
		/// superdiagonals of an intermediate bidiagonal form B
		/// did not converge to zero.</item>
		/// </list></returns>
		/// <remarks><paramref name="jobvt"/> and <paramref name="jobu"/> cannot both be 'O'.</remarks>
		int Dgesvd(char jobu, char jobvt, int m, int n, double[] a, int lda, double[] s, double[] u, int ldu, double[] vt, int ldvt);

		/// <summary>
		/// Computes the singular value decomposition (SVD) of a complex
		/// M by N matrix A, optionally computing the left and/or right singular
		/// vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V)
		/// where SIGMA is an M by N matrix which is zero except for its
		/// min(m,n) diagonal elements, U is an M by M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA
		/// are the singular values of A. They are real and non-negative, and
		/// are returned in descending order. The first min(m,n) columns of
		/// U and V are the left and right singular vectors of A.
		/// Note that the routine returns V**T, not V.
		/// </summary>
		/// <param name="jobu">
		/// Specifies options for computing all or part of the matrix <paramref name="u"/>:
		/// <list>
		/// <item> = '<paramref name="a"/>': all <paramref name="m"/> columns of <paramref name="u"/> are returned in array <paramref name="u"/>.</item>
		/// <item> = '<paramref name="s"/>': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are returned in the array <paramref name="u"/>.</item>
		/// <item> = 'O': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item> = '<paramref name="n"/>': no columns of <paramref name="u"/> (no left singular vectors) are computed. </item>
		/// </list>
		/// </param>
		/// <param name="jobvt">
		/// Specifies options for computing all or part of the matrix V**T:
		/// <list>
		/// <item>'<paramref name="a"/>': all <paramref name="n"/> rows of V**T are returned in the array <paramref name="vt"/>.</item>
		/// <item>'<paramref name="s"/>': the first min(m,n) rows of V**T (the right singular vectors) are returned in the array <paramref name="vt"/>.</item>
		/// <item>'O': the first min(m,n) rows of V**T (the right singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item>'<paramref name="n"/>': no rows of V**T (no right singular vectors) are computed.</item>
		/// </list>
		/// </param>
		/// <param name="m">The number of rows of the input matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the input matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit:<list>
		/// <item>if <paramref name="jobu"/> == 'O', <c>a</c> is overwritten with the first min(m,n) columns of <paramref name="u"/> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobvt"/> == 'O', <c>a</c> is overwritten with the first min(m,n)rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>if <paramref name="jobu"/> != 'O' and <paramref name="jobvt"/> != 'O', the contents of <c>a</c> are destroyed.</item>
		/// </list></param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The singular values of <paramref name="a"/>, sorted so that <c>s[i] &gt;= s[i+1]</c>.</param>
		/// <param name="u">Dimension <paramref name="ldu"/> by UCOL, <paramref name="ldu"/> by <paramref name="m"/> if <paramref name="jobu"/> = '<paramref name="a"/>', or <paramref name="ldu"/> by min(<paramref name="m"/>,<paramref name="n"/>) if <paramref name="jobu"/> = '<paramref name="s"/>'.
		/// <list>
		/// <item>If <paramref name="jobu"/> == '<paramref name="a"/>', <c>u</c> contains the <paramref name="m"/> by <paramref name="m"/> orthogonal matrix <c>u</c>.</item>
		/// <item>If <paramref name="jobu"/> == '<paramref name="s"/>', <c>u</c> contains the first min(m,n) columns of <c>u</c> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobu"/> == '<paramref name="n"/>' or 'O', <c>u</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldu">The leading dimension of the array <paramref name="u"/>. <c>ldu &gt;= 1</c>. If <paramref name="jobu"/> = '<paramref name="s"/>' or '<paramref name="a"/>', <c>ldu &gt;= <paramref name="m"/></c>.</param>
		/// <param name="vt">Dimension <paramref name="ldvt"/> by <paramref name="n"/>.
		/// <list>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="a"/>', <c>vt</c> contains the <paramref name="n"/> by <paramref name="n"/> orthogonal matrix V**T.</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="s"/>', <c>vt</c> contains the first min(m,n) rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="n"/>' or 'O', <c>vt</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldvt">The leading dimension of the array <paramref name="vt"/>. <c>ldvt &gt;= 1</c>. If <paramref name="jobvt"/> == '<paramref name="a"/>', 
		/// <c>ldvt &gt;= <paramref name="n"/></c>; if <paramref name="jobvt"/> == '<paramref name="s"/>', <c><paramref name="ldvt"/> &gt;= min(<paramref name="m"/>,<paramref name="n"/>)</c>.</param>
		/// <param name="work">Work array. The length of <c>work</c> should be at least max(3*min(<paramref name="m"/>,<paramref name="n"/>)+max(<paramref name="m"/>,<paramref name="n"/>),5*min(<paramref name="m"/>,<paramref name="n"/>)).
		/// On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use. 
		/// If the method returns a value greater than 0, <c>work[1:min(<paramref name="m"/>,<paramref name="n"/>)-1]</c> contains the unconverged superdiagonal elements of an upper bidiagonal
		/// matrix B whose diagonal is in <paramref name="s"/> (not necessarily sorted).
		/// B satisfies <paramref name="a"/> = <paramref name="u"/> * B * <paramref name="vt"/>, so it has the same singular
		/// values as <paramref name="a"/>, and singular vectors related by <paramref name="u"/> and <paramref name="vt"/>.</param>
		/// <returns><list>
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: if DBDSQR did not converge, specifies how many
		/// superdiagonals of an intermediate bidiagonal form B
		/// did not converge to zero.See the description of <paramref name="work"/>
		/// above for details.</item>
		/// </list></returns>
		/// <remarks><paramref name="jobvt"/> and <paramref name="jobu"/> cannot both be 'O'.</remarks>
		int Dgesvd(char jobu, char jobvt, int m, int n, double[] a, int lda, double[] s, double[] u, int ldu, double[] vt, int ldvt, double[] work);

		/// <summary>
		/// Computes an LU factorization of a general M by N matrix A
		/// using partial pivoting with row interchanges. 
		/// The factorization has the form A = P * L * U
		/// where P is a permutation matrix, L is lower triangular with unit
		/// diagonal elements (lower trapezoidal if m &gt; n), and U is upper
		/// triangular (upper trapezoidal if m &lt; n).
		/// This is the right-looking Level 3 BLAS version of the algorithm.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimensions <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/>-by-<paramref name="n"/> matrix to be factored.
		/// On exit, the factors L and U from the factorization
		/// A = P*L*U. The unit diagonal elements of L are not stored.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="ipiv">Dimension min(<paramref name="m"/>,<paramref name="n"/>).
		/// The pivot indices. for 0 &lt;= i &lt;= min(<paramref name="m"/>,<paramref name="n"/>), row i of the matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <returns>
		/// <list> 
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: U[i,i] is exactly zero. The factorization has been completed, but the factor U is exactly
		///	singular, and division by zero will occur if it is used
		/// to solve a system of equations.</item>
		/// </list></returns>
		int Dgetrf(int m, int n, double[] a, int lda, out int[] ipiv);

		/// <summary>
		/// Computes the inverse of a matrix using the LU factorization
		/// computed by DGETRF. This method inverts U and then computes 
		/// inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
		/// </summary>
		/// <param name="n"> The order of the matrix <parmaref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <parmaref name="lda"/> by <parmaref name="n"/>. On entry, the factors L and U from the factorization
		/// A = P*L*U as computed by DGETRF.
		/// On exit, the inverse of the original matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <parmaref name="a"/>. <c>lda</c> &gt;= max(1,<parmaref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from DGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value</item>
		/// <item>&gt; 0: U[i,i] is exactly zero; the matrix is
		/// singular and its inverse could not be computed.</item>
		/// </list></returns>
		int Dgetri(int n, double[] a, int lda, int[] ipiv);

		/// <summary>
		/// Computes the inverse of a matrix using the LU factorization
		/// computed by DGETRF. This method inverts U and then computes 
		/// inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
		/// </summary>
		/// <param name="n"> The order of the matrix <parmaref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <parmaref name="lda"/> by <parmaref name="n"/>. On entry, the factors L and U from the factorization
		/// A = P*L*U as computed by DGETRF.
		/// On exit, the inverse of the original matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <parmaref name="a"/>. <c>lda</c> &gt;= max(1,<parmaref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from DGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <param name="work">Work array. The length of <c>work</c> should be at least <paramref name="n"/>*NB,
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value</item>
		/// <item>&gt; 0: U[i,i] is exactly zero; the matrix is
		/// singular and its inverse could not be computed.</item>
		/// </list></returns>
		int Dgetri(int n, double[] a, int lda, int[] ipiv, double[] work);

		/// <summary>
		/// Solves a system of linear equations A * X = B or A' * X = B
		/// with a general N by N matrix A using the LU factorization computed by DGETRF.
		/// </summary>
		/// <param name="trans"> Specifies the form of the system of equations:
		/// <list>
		/// <item>'N': A * X = B (No transpose)</item>
		/// <item>'T': A'* X = B (Transpose)</item>
		/// <item>'C': A'* X = B (Conjugate transpose = Transpose)</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns
		/// of the matrix <paramref name="b"/>. <c>nrhs &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by DGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from DGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <param name="b">Dimension <parmaref name="ldb"/> by <parmaref name="nrhs"/>.
		/// On entry, the right hand side matrix <c>b</c>.
		/// On exit, the solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dgetrs(char trans, int n, int nrhs, double[] a, int lda, int[] ipiv, double[] b, int ldb);

		/// <summary>
		/// Generates an M by N real matrix Q with orthonormal columns,
		/// which is defined as the first N columns of a product of K elementary
		/// reflectors of order M: <code>Q = H(0) H(1) . . . H(k-1)</code>
		/// as returned by DGEQRF.
		/// </summary>
		/// <param name="m">The number of rows of the matrix Q. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix Q. <c>m &gt;= n &gt;= 0</c></param>
		/// <param name="k">The number of elementary reflectors whose product defines the matrix Q. <c>n &gt;= k &gt;= 0</c>.</param>
		/// <param name="a">Dimension LDA by N.
		/// On entry, the i-th column must contain the vector which defines the elementary reflector H(0), for i = 0,2,...,k-1, as
		/// returned by DGEQRF in the first k columns of its array argument <c>a</c>.
		/// On exit, the <parmaref name="m"/> by <parmaref name="n"/> matrix Q.</param>
		/// <param name="lda">The first dimension of the array <parmaref name="a"/> . <c>lda</c> &gt;= max(1,<parmaref name="m"/>).</param>
		/// <param name="tau">Dimension K. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by DGEQRF.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dorgqr(int m, int n, int k, double[] a, int lda, double[] tau);

		/// <summary>
		/// Generates an M by N real matrix Q with orthonormal columns,
		/// which is defined as the first N columns of a product of K elementary
		/// reflectors of order M: <code>Q = H(0) H(1) . . . H(k-1)</code>
		/// as returned by DGEQRF.
		/// </summary>
		/// <param name="m">The number of rows of the matrix Q. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix Q. <c>m &gt;= n &gt;= 0</c></param>
		/// <param name="k">The number of elementary reflectors whose product defines the matrix Q. <c>n &gt;= k &gt;= 0</c>.</param>
		/// <param name="a">Dimension LDA by N.
		/// On entry, the i-th column must contain the vector which defines the elementary reflector H(0), for i = 0,2,...,k-1, as
		/// returned by DGEQRF in the first k columns of its array argument <c>a</c>.
		/// On exit, the <parmaref name="m"/> by <parmaref name="n"/> matrix Q.</param>
		/// <param name="lda">The first dimension of the array <parmaref name="a"/> . <c>lda</c> &gt;= max(1,<parmaref name="m"/>).</param>
		/// <param name="tau">Dimension K. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by DGEQRF.</param>
		/// <param name="work">Work array. The length of <c>work</c> should be at least <paramref name="n"/>*NB,
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <c>work[0]</c> returns the optimal length of <c>work</c> to use.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dorgqr(int m, int n, int k, double[] a, int lda, double[] tau, double[] work);

		/// <summary>
		/// <para>Overwrites the general real M-by-N matrix C with</para>
		/// <pre>             SIDE = 'L'    SIDE = 'R'</pre>
		/// <pre>TRANS = 'N':   Q * C         C * Q</pre>
		/// <pre>TRANS = 'T':   Q**T * C      C * Q**T</pre>																		
		/// <para>where Q is a real orthogonal matrix defined as the product of k elementary reflectors
		/// Q = H(0) H(1) . . . H(k-1) as returned by DGEQRF. Q is of order M if 
		/// SIDE == 'L' and of order N if SIDE == 'R'.</para>
		/// </summary>
		/// <param name="side"><list>
		/// <item>'L': apply Q or Q**T from the Left.</item>
		/// <item>'R': apply Q or Q**T from the Right.</item>
		/// </list></param>
		/// <param name="trans"><list>
		/// <item>'N': No transpose, apply Q;</item>
		/// <item>'T': Transpose, apply Q**T.</item>
		/// </list></param>
		/// <param name="m">The number of rows of the matrix <paramref name="c"/>. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="c"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="k"> The number of elementary reflectors whose product defines the matrix Q.
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="m"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// <item>If <paramref name="side"/> == 'R', <paramref name="n"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// </list></param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="k"/>.
		/// The i-th column must contain the vector which defines the
		/// elementary reflector H(i), for i = 0,2,...,<paramref name="k"/>-1, as returned by
		///	DGEQRF in the first <paramref name="k"/> columns of its array argument <paramref name="a"/>.
		///	<paramref name="a"/> is modified by the routine but restored on exit.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/> .
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <c>lda</c> &gt;= max(1,<paramref name="m"/>).</item>
		/// <item>If <paramref name="side"/> == 'R', <c>lda</c> &gt;= max(1,<paramref name="n"/>).</item>
		/// </list></param>
		/// <param name="tau">Dimension <paramref name="k"/>. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by DGEQRF.</param>
		/// <param name="c">dimension <paramref name="ldc"/> by <paramref name="n"/>. 
		/// On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>c</c>.
		/// On exit, <c>c</c> is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.</param>
		/// <param name="ldc">The leading dimension of the array <paramref name="c"/>.<c>ldc</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dormqr(char side, char trans, int m, int n, int k, double[] a, int lda, double[] tau, double[] c, int ldc);

		/// <summary>
		/// <para>Overwrites the general real M-by-N matrix C with</para>
		/// <pre>             SIDE = 'L'    SIDE = 'R'</pre>
		/// <pre>TRANS = 'N':   Q * C         C * Q</pre>
		/// <pre>TRANS = 'T':   Q**T * C      C * Q**T</pre>																		
		/// <para>where Q is a real orthogonal matrix defined as the product of k elementary reflectors
		/// Q = H(0) H(1) . . . H(k-1) as returned by DGEQRF. Q is of order M if 
		/// SIDE == 'L' and of order N if SIDE == 'R'.</para>
		/// </summary>
		/// <param name="side"><list>
		/// <item>'L': apply Q or Q**T from the Left.</item>
		/// <item>'R': apply Q or Q**T from the Right.</item>
		/// </list></param>
		/// <param name="trans"><list>
		/// <item>'N': No transpose, apply Q;</item>
		/// <item>'T': Transpose, apply Q**T.</item>
		/// </list></param>
		/// <param name="m">The number of rows of the matrix <paramref name="c"/>. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="c"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="k"> The number of elementary reflectors whose product defines the matrix Q.
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="m"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// <item>If <paramref name="side"/> == 'R', <paramref name="n"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// </list></param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="k"/>.
		/// The i-th column must contain the vector which defines the
		/// elementary reflector H(i), for i = 0,2,...,<paramref name="k"/>-1, as returned by
		///	DGEQRF in the first <paramref name="k"/> columns of its array argument <paramref name="a"/>.
		///	<paramref name="a"/> is modified by the routine but restored on exit.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/> .
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <c>lda</c> &gt;= max(1,<paramref name="m"/>).</item>
		/// <item>If <paramref name="side"/> == 'R', <c>lda</c> &gt;= max(1,<paramref name="n"/>).</item>
		/// </list></param>
		/// <param name="tau">Dimension <paramref name="k"/>. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by DGEQRF.</param>
		/// <param name="c">dimension <paramref name="ldc"/> by <paramref name="n"/>. 
		/// On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>c</c>.
		/// On exit, <c>c</c> is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.</param>
		/// <param name="ldc">The leading dimension of the array <paramref name="c"/>.<c>ldc</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="work">Work array. The length of <c>work</c> should be:
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="n"/> * NB.</item>
		/// <item>if <paramref name="side"/> == 'R', <paramref name="m"/> * NB.</item>
		/// </list>
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <c>work[0]</c> returns the optimal length of <c>work</c> to use.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dormqr(char side, char trans, int m, int n, int k, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);

		/// <summary>
		/// Computes the Cholesky factorization of a real symmetric
		/// positive definite matrix A.
		/// The factorization has the form 
		/// <code>
		/// A = U**T * U, if UPLO == 'U' 
		/// A = L * L**T, if UPLO == 'L'
		/// </code>
		/// where U is an upper triangular matrix and L is lower triangular.
		/// This is the block version of the algorithm, calling Level 3 BLAS.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// On entry, the symmetric matrix <c>a</c>. 
		/// If <paramref name="uplo"/> == 'U', the leading <paramref name="n"/> by <paramref name="n"/> upper triangular part of <c>a</c>
		/// contains the upper triangular part of the matrix <c>a</c>, and the strictly lower triangular part of <c>a</c> is not referenced.
		/// If <paramref name="uplo"/> == 'L', the leading <paramref name="n"/> by <paramref name="n"/> lower triangular part of <c>a</c>
		/// contains the lower triangular part of the matrix <c>a</c>, and the strictly upper triangular part of <c>a</c> is not referenced.
		/// On exit, the factor U or L from the Cholesky factorization <c>A = U**T*U or A = L*L**T</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value</item>
		/// <item>&gt; 0: the leading minor of order i is not positive definite, and the factorization could not be completed.</item>
		/// </list></returns>
		int Dpotrf(char uplo, int n, double[] a, int lda);

		/// <summary>
		/// Computes the inverse of a real symmetric positive definite
		/// matrix A using the Cholesky factorization A = U**T*U or A = L*L**T
		/// computed by DPOTRF.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// On entry, the triangular factor U or L from the Cholesky
		/// factorization A = U**T*U or A = L*L**T, as computed by DPOTRF.
		/// On exit, the upper or lower triangle of the (symmetric) inverse of <c>a</c>, 
		/// overwriting the input factor U or L.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the [i,i] element of the factor U or L is zero, and the inverse could not be computed.</item>
		/// </list></returns>
		int Dpotri(char uplo, int n, double[] a, int lda);

		/// <summary>
		/// Solves a system of linear equations A*X = B with a symmetric
		/// positive definite matrix A using the Cholesky factorization
		/// <code>A = U**T*U or A = L*L**T</code> computed by DPOTRF.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns
		/// of the matrix <paramref name="b"/>. <c>nrhs &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The triangular factor U or L from the Cholesky factorization
		/// A = U**T*U or A = L*L**T, as computed by DPOTRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>.
		/// On entry, the right hand side matrix <c>b</c>.
		/// On exit, the solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dpotrs(char uplo, int n, int nrhs, double[] a, int lda, double[] b, int ldb);

		/// <summary>
		/// Computes the least squares solution to an over-determined system of linear equations, A*X=B, or the minimum norm
		/// solution of an under-determined system, where A is a general rectangular matrix of full rank, using a QR or LQ factorization
		/// of A or underdetermined linear system with full rank matrix.
		/// </summary>
		/// <param name="trans">If <c>trans</c> == 'N': the linear system involves <paramref name="a"/>. If <c>trans</c> == 'T': the linear system involves <paramref name="a"/>'.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m</c> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n</c> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrix <paramref name="b"/>. <c>nrhs</c> &gt;=0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix. On exit, if <paramref name="m"/> >= <paramref name="n"/>, 
		/// <paramref name="a"/> is overwritten by details of its QR factorization as returned by Sgeqrf. Otherwise, <paramref name="a"/> is 
		/// overwritten by details of its LQ factorization as returned by Sgelqf.</param>
		/// <param name="lda">The leading dimension of <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b"> Dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>). On entry, the matrix <c>b</c> of right hand side vectors, stored columnwise. 
		/// b is <paramref name="m"/> by <paramref name="nrhs"/> if <paramref name="trans"/> == 'N', or <paramref name="n"/> by <paramref name="n"/> by <paramref name="nrhs"/>
		/// if <paramref name="trans"/> == 'T'. On exit, <c>b</c> is overwritten by the solution vectors, stored columnwise: 
		/// <list>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="n"/> to <paramref name="m"/>-1 in that column.</item>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &lt; <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &lt;<paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="m"/> to <paramref name="n"/>-1 in that column.</item>
		/// </list></param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cgels(char trans, int m, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb);

		/// <summary>
		/// Computes the least squares solution to an over-determined system of linear equations, A*X=B, or the minimum norm
		/// solution of an under-determined system, where A is a general rectangular matrix of full rank, using a QR or LQ factorization
		/// of A or underdetermined linear system with full rank matrix.
		/// </summary>
		/// <param name="trans">If <c>trans</c> == 'N': the linear system involves <paramref name="a"/>. If <c>trans</c> == 'T': the linear system involves <paramref name="a"/>'.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m</c> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n</c> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrix <paramref name="b"/>. <c>nrhs</c> &gt;=0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix. On exit, if <paramref name="m"/> >= <paramref name="n"/>, 
		/// <paramref name="a"/> is overwritten by details of its QR factorization as returned by Sgeqrf. Otherwise, <paramref name="a"/> is 
		/// overwritten by details of its LQ factorization as returned by Sgelqf.</param>
		/// <param name="lda">The leading dimension of <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b"> Dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>). On entry, the matrix <c>b</c> of right hand side vectors, stored columnwise. 
		/// b is <paramref name="m"/> by <paramref name="nrhs"/> if <paramref name="trans"/> == 'N', or <paramref name="n"/> by <paramref name="n"/> by <paramref name="nrhs"/>
		/// if <paramref name="trans"/> == 'T'. On exit, <c>b</c> is overwritten by the solution vectors, stored columnwise: 
		/// <list>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="n"/> to <paramref name="m"/>-1 in that column.</item>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &lt; <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &lt;<paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="m"/> to <paramref name="n"/>-1 in that column.</item>
		/// </list></param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="work">Work array. On exit, <c>work[0]</c> equals the optimal length the work array should be.
		/// The length of <c>work</c> should be at least max( 1, MN + max( MN, <paramref name="nrhs"/> ) ). For optimal performance,
		/// The length of <c>work</c> should be at least max( 1, MN + max( MN, <paramref name="nrhs"/> )*NB ), where MN = min(<paramref name="m"/>,<paramref name="n"/>) and NB is the optimum block size.
		/// </param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cgels(char trans, int m, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] work);

		/// <summary>
		/// <para>Computes the minimum norm solution to a real linear least squares problem:</para>
		/// <para>Minimize 2-norm(| B - A*X |)</para>
		/// <para>using the singular value decomposition (SVD) of A. A is an M by N matrix which may be rank-deficient.
		/// Several right hand side vectors B and solution vectors X can be handled in a single call. They are stored as the columns of the
		/// M by NRHS right hand side matrix B and the N by NRHS solution matrix X.
		/// The effective rank of A is determined by treating as zero those singular values which are less than rcond times the largest singular value.</para>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <paramref name="a"/>. On exit, the first min(<paramref name="m"/>,n) rows of <paramref name="a"/> 
		/// are overwritten with its right singular vectors, stored rowwise.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>. On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, <paramref name="b"/> is overwritten by the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X. If <paramref name="m"/> &gt;= <paramref name="n"/> and RANK = <paramref name="n"/>, the residual
		/// sum-of-squares for the solution in the i-th column is given	by the sum of squares of elements <paramref name="n"/>:<paramref name="m"/>-1 in that column.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,max(<paramref name="m"/>,<paramref name="n"/>)).</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>) The singular values of <paramref name="a"/> in decreasing order. The condition number of <paramref name="a"/> 
		/// in the 2-norm = <paramref name="s"/>[0]/<paramref name="s"/>[min(<paramref name="m"/>,<paramref name="n"/>)-1].</param>
		/// <param name="rank">The effective rank of A.</param>
		/// <returns> <list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the algorithm for computing the SVD failed to converge. i-th off-diagonal elements of an intermediate
		/// bidiagonal form did not converge to zero.</item>
		/// </list></returns>
		int Cgelss(int m, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, out float[] s, ref int rank);

		/// <summary>
		/// <para>Computes the minimum norm solution to a real linear least squares problem:</para>
		/// <para>Minimize 2-norm(| B - A*X |)</para>
		/// <para>using the singular value decomposition (SVD) of A. A is an M by N matrix which may be rank-deficient.
		/// Several right hand side vectors B and solution vectors X can be handled in a single call. They are stored as the columns of the
		/// M by NRHS right hand side matrix B and the N by NRHS solution matrix X.
		/// The effective rank of A is determined by treating as zero those singular values which are less than rcond times the largest singular value.</para>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <paramref name="a"/>. On exit, the first min(<paramref name="m"/>,n) rows of <paramref name="a"/> 
		/// are overwritten with its right singular vectors, stored rowwise.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>. On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, <paramref name="b"/> is overwritten by the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X. If <paramref name="m"/> &gt;= <paramref name="n"/> and RANK = <paramref name="n"/>, the residual
		/// sum-of-squares for the solution in the i-th column is given	by the sum of squares of elements <paramref name="n"/>:<paramref name="m"/>-1 in that column.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,max(<paramref name="m"/>,<paramref name="n"/>)).</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>) The singular values of <paramref name="a"/> in decreasing order. The condition number of <paramref name="a"/> 
		/// in the 2-norm = S[0]/S[min(<paramref name="m"/>,<paramref name="n"/>)-1].</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>. Singular values <paramref name="s"/>[i] &lt;= <c>rcond</c>*<paramref name="s"/>[0] are treated as zero.
		/// If <c>rcond</c> &lt; 0, machine precision is used instead.</param>
		/// <param name="rank">The effective rank of A, i.e., the number of singular values which are greater than <paramref name="rcond"/>*<paramref name="s"/>[0].</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.
		/// The length of <c>work</c> should be at least 2*min(<paramref name="m"/>,<paramref name="n"/>) + max(<paramref name="m"/>,<paramref name="n"/>,<paramref name="nrhs"/>).
		/// </param>
		/// <param name="rwork">Dimension 5*min(<paramref name="m"/>,<paramref name="n"/>)</param>
		/// <returns> <list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the algorithm for computing the SVD failed to converge. i-th off-diagonal elements of an intermediate
		/// bidiagonal form did not converge to zero.</item>
		/// </list></returns>
		int Cgelss(int m, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, out float[] s, float rcond, ref int rank, ComplexFloat[] work, float[] rwork);

		/// <summary>
		/// <para>Computes the minimum-norm solution to a real linear least squares problem:</para>
		/// <para>minimize || A * X - B ||</para>
		/// <para>using a complete orthogonal factorization of A. A is an M by N
		/// matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be
		/// handled in a single call; they are stored as the columns of the M by NRHS right hand side matrix B 
		/// and the N by NRHS solution matrix X. The routine first computes a QR factorization with column pivoting:
		/// <code>
		/// A * P = Q * [ R00 R01 ]
		///             [ 0   R11 ]
		/// </code>
		/// with R11 defined as the largest leading submatrix whose estimated
		/// condition number is less than 1/RCOND. The order of R11, RANK,
		/// is the effective rank of A.</para>
		/// <para>Then, R22 is considered to be negligible, and R12 is annihilated
		/// by orthogonal transformations from the right, arriving at the complete orthogonal factorization:
		/// <code>
		/// A * P = Q * [ T00 0 ] * Z
		///             [ 0   0 ]
		/// </code>
		/// The minimum-norm solution is then
		/// <code>
		/// X = P * Z' [ inv(T00)*Q0'*B ]
		///            [        0       ]
		/// </code>
		/// where Q0 consists of the first RANK columns of Q.</para>
		/// This routine is basically identical to the original xGELSX except three differences:
		/// <list>
		/// <item>The call to the subroutine xGEQPF has been substituted by the
		/// the call to the subroutine xGEQP3. This subroutine is a Blas-3
		/// version of the QR factorization with column pivoting.</item>
		/// <item>Matrix B (the right hand side) is updated with Blas-3.</item>
		/// <item>The permutation of matrix B (the right hand side) is faster and more simple.</item>
		/// </list>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of
		/// columns of matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, <c>a</c> has been overwritten by details of its complete orthogonal factorization.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>)
		/// On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="jpvt">On entry, if <c>jpvt[i] != 0</c>, the i-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>P, otherwise column i is a free column.
		/// On exit, if <c>jpvt[i] = k</c>, then the i-th column of <paramref name="a"/>P
		/// was the k-th column of <paramref name="a"/>.</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>, which
		/// is defined as the order of the largest leading triangular
		/// submatrix R00 in the QR factorization with pivoting of <paramref name="a"/>,
		/// whose estimated condition number &lt; <c>1/rcond</c>.</param>
		/// <param name="rank"> The effective rank of <paramref name="a"/>, i.e., the order of the submatrix
		/// R00. This is the same as the order of the submatrix T00
		/// in the complete orthogonal factorization of <paramref name="a"/>.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cgelsy(int m, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, int[] jpvt, float rcond, ref int rank);

		/// <summary>
		/// <para>Computes the minimum-norm solution to a real linear least squares problem:</para>
		/// <para>minimize || A * X - B ||</para>
		/// <para>using a complete orthogonal factorization of A. A is an M by N
		/// matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be
		/// handled in a single call; they are stored as the columns of the M by NRHS right hand side matrix B 
		/// and the N by NRHS solution matrix X. The routine first computes a QR factorization with column pivoting:
		/// <code>
		/// A * P = Q * [ R00 R01 ]
		///             [ 0   R11 ]
		/// </code>
		/// with R11 defined as the largest leading submatrix whose estimated
		/// condition number is less than 1/RCOND. The order of R11, RANK,
		/// is the effective rank of A.</para>
		/// <para>Then, R22 is considered to be negligible, and R12 is annihilated
		/// by orthogonal transformations from the right, arriving at the complete orthogonal factorization:
		/// <code>
		/// A * P = Q * [ T00 0 ] * Z
		///             [ 0   0 ]
		/// </code>
		/// The minimum-norm solution is then
		/// <code>
		/// X = P * Z' [ inv(T00)*Q0'*B ]
		///            [        0       ]
		/// </code>
		/// where Q0 consists of the first RANK columns of Q.</para>
		/// This routine is basically identical to the original xGELSX except three differences:
		/// <list>
		/// <item>The call to the subroutine xGEQPF has been substituted by the
		/// the call to the subroutine xGEQP3. This subroutine is a Blas-3
		/// version of the QR factorization with column pivoting.</item>
		/// <item>Matrix B (the right hand side) is updated with Blas-3.</item>
		/// <item>The permutation of matrix B (the right hand side) is faster and more simple.</item>
		/// </list>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of
		/// columns of matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, <c>a</c> has been overwritten by details of its complete orthogonal factorization.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>)
		/// On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="jpvt">On entry, if <c>jpvt[i] != 0</c>, the i-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>P, otherwise column i is a free column.
		/// On exit, if <c>jpvt[i] = k</c>, then the i-th column of <paramref name="a"/>P
		/// was the k-th column of <paramref name="a"/>.</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>, which
		/// is defined as the order of the largest leading triangular
		/// submatrix R00 in the QR factorization with pivoting of <paramref name="a"/>,
		/// whose estimated condition number &lt; <c>1/rcond</c>.</param>
		/// <param name="rank"> The effective rank of <paramref name="a"/>, i.e., the order of the submatrix
		/// R00. This is the same as the order of the submatrix T00
		/// in the complete orthogonal factorization of <paramref name="a"/>.</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.
		/// The length of <c>work</c> should be at least MN + MAX( 2*MN, NB*(<paramref name="n"/>+1), MN+MN*NB, MN+NB*<paramref name="nrhs"/> ) 
		/// where MN = min( <paramref name="m"/>, <paramref name="n"/> ) and NB is an upper bound on the blocksize returned by ILAENV
		/// for the routines CGEQP3, CTZRZF, CTZRQF, CUNMQR, and CUNMRZ.</param>
		/// <param name="rwork">Dimension 2*<paramref name="n"/></param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cgelsy(int m, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, int[] jpvt, float rcond, ref int rank, ComplexFloat[] work, float[] rwork);

		/// <summary>
		/// Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, the upper triangle of the array contains the
		/// min(<paramref name="m"/>,<paramref name="n"/>) by <paramref name="n"/> upper trapezoidal matrix R. The elements below
		/// the diagonal, together with the array <paramref name="tau"/>, represent the
		/// unitary matrix Q as a product of min(<paramref name="m"/>,<paramref name="n"/>) elementary
		/// reflectors.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="jpvt">Dimension <paramref name="n"/>.
		/// On entry, if <c>jpvt[j] != 0</c>, the j-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>*P (a leading column); if <c>jpvt[j] == 0</c>,
		/// the j-th column of <paramref name="a"/> is a free column.
		/// On exit, if <c>jpvt[j] == k</c>, then the j-th column of <paramref name="a"/>*P was the
		/// the k-th column of <paramref name="a"/>.</param>
		/// <param name="tau">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The scalar factors of the elementary reflectors.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cgeqp3(int m, int n, ComplexFloat[] a, int lda, int[] jpvt, ComplexFloat[] tau);

		/// <summary>
		/// Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, the upper triangle of the array contains the
		/// min(<paramref name="m"/>,<paramref name="n"/>) by <paramref name="n"/> upper trapezoidal matrix R. The elements below
		/// the diagonal, together with the array <paramref name="tau"/>, represent the
		/// unitary matrix Q as a product of min(<paramref name="m"/>,<paramref name="n"/>) elementary
		/// reflectors.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="jpvt">Dimension <paramref name="n"/>.
		/// On entry, if <c>jpvt[j] != 0</c>, the j-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>*P (a leading column); if <c>jpvt[j] == 0</c>,
		/// the j-th column of <paramref name="a"/> is a free column.
		/// On exit, if <c>jpvt[j] == k</c>, then the j-th column of <paramref name="a"/>*P was the
		/// the k-th column of <paramref name="a"/>.</param>
		/// <param name="tau">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The scalar factors of the elementary reflectors.</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use. 
		/// The dimension of <c>work</c> &gt;= <paramref name="n"/>+1.
		/// For optimal performance The dimension of <c>work</c> &gt;= ( <paramref name="n"/>+1 )*NB, where NB is the optimal blocksize.</param>
		/// <param name="rwork">Dimension 2*<paramref name="n"/></param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cgeqp3(int m, int n, ComplexFloat[] a, int lda, int[] jpvt, ComplexFloat[] tau, ComplexFloat[] work, float[] rwork);

		/// <summary>
		/// Computes an LU factorization of a general M by N matrix A
		/// using partial pivoting with row interchanges. 
		/// The factorization has the form A = P * L * U
		/// where P is a permutation matrix, L is lower triangular with unit
		/// diagonal elements (lower trapezoidal if m &gt; n), and U is upper
		/// triangular (upper trapezoidal if m &lt; n).
		/// This is the right-looking Level 3 BLAS version of the algorithm.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimensions <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/>-by-<paramref name="n"/> matrix to be factored.
		/// On exit, the factors L and U from the factorization
		/// A = P*L*U. The unit diagonal elements of L are not stored.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="ipiv">Dimension min(<paramref name="m"/>,<paramref name="n"/>).
		/// The pivot indices. for 0 &lt;= i &lt;= min(<paramref name="m"/>,<paramref name="n"/>), row i of the matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <returns>
		/// <list> 
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: U[i,i] is exactly zero. The factorization has been completed, but the factor U is exactly
		///	singular, and division by zero will occur if it is used
		/// to solve a system of equations.</item>
		/// </list></returns>
		int Cgetrf(int m, int n, ComplexFloat[] a, int lda, out int[] ipiv);

		/// <summary>
		/// Computes the inverse of a matrix using the LU factorization
		/// computed by CGETRF. This method inverts U and then computes 
		/// inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
		/// </summary>
		/// <param name="n"> The order of the matrix <parmaref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <parmaref name="lda"/> by <parmaref name="n"/>. On entry, the factors L and U from the factorization
		/// A = P*L*U as computed by CGETRF.
		/// On exit, the inverse of the original matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <parmaref name="a"/>. <c>lda</c> &gt;= max(1,<parmaref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from CGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value</item>
		/// <item>&gt; 0: U[i,i] is exactly zero; the matrix is
		/// singular and its inverse could not be computed.</item>
		/// </list></returns>
		int Cgetri(int n, ComplexFloat[] a, int lda, int[] ipiv);

		/// <summary>
		/// Computes the inverse of a matrix using the LU factorization
		/// computed by CGETRF. This method inverts U and then computes 
		/// inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
		/// </summary>
		/// <param name="n"> The order of the matrix <parmaref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <parmaref name="lda"/> by <parmaref name="n"/>. On entry, the factors L and U from the factorization
		/// A = P*L*U as computed by CGETRF.
		/// On exit, the inverse of the original matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <parmaref name="a"/>. <c>lda</c> &gt;= max(1,<parmaref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from CGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <param name="work">Work array. The length of <c>work</c> should be at least <paramref name="n"/>*NB,
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: U[i,i] is exactly zero; the matrix is
		/// singular and its inverse could not be computed.</item>
		/// </list></returns>
		int Cgetri(int n, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] work);

		/// <summary>
		/// Solves a system of linear equations <code>A * X = B, A**T * X = B, or A**H * X = B</code>
		/// with a general N by N matrix A using the LU factorization computed by CGETRF.
		/// </summary>
		/// <param name="trans"> Specifies the form of the system of equations:
		/// <list>
		/// <item>'N': A * X = B (No transpose)</item>
		/// <item>'T': A**T * X = B (Transpose)</item>
		/// <item>'C': A**H * X = B (Conjugate transpose)</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns
		/// of the matrix <paramref name="b"/>. <c>nrhs &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by CGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from CGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <param name="b">Dimension <parmaref name="ldb"/> by <parmaref name="nrhs"/>.
		/// On entry, the right hand side matrix <c>b</c>.
		/// On exit, the solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cgetrs(char trans, int n, int nrhs, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] b, int ldb);

		/// <summary>
		/// Computes the Cholesky factorization of a Hermitian
		/// positive definite matrix A.
		/// The factorization has the form 
		/// <code>
		/// A = U**H * U, if UPLO == 'U' 
		/// A = L * L**H, if UPLO == 'L'
		/// </code>
		/// where U is an upper triangular matrix and L is lower triangular.
		/// This is the block version of the algorithm, calling Level 3 BLAS.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// On entry, the Hermitian matrix <c>a</c>. 
		/// If <paramref name="uplo"/> == 'U', the leading <paramref name="n"/> by <paramref name="n"/> upper triangular part of <c>a</c>
		/// contains the upper triangular part of the matrix <c>a</c>, and the strictly lower triangular part of <c>a</c> is not referenced.
		/// If <paramref name="uplo"/> == 'L', the leading <paramref name="n"/> by <paramref name="n"/> lower triangular part of <c>a</c>
		/// contains the lower triangular part of the matrix <c>a</c>, and the strictly upper triangular part of <c>a</c> is not referenced.
		/// On exit, the factor U or L from the Cholesky factorization <c>A = U**H*U or A = L*L**H</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the leading minor of order i is not positive definite, and the factorization could not be completed.</item>
		/// </list></returns>
		int Cpotrf(char uplo, int n, ComplexFloat[] a, int lda);

		/// <summary>
		/// Computes the inverse of a Hermitian positive definite
		/// matrix A using the Cholesky factorization A = U**H*U or A = L*L**H
		/// computed by CPOTRF.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// On entry, the triangular factor U or L from the Cholesky
		/// factorization A = U**H*U or A = L*L**H, as computed by CPOTRF.
		/// On exit, the upper or lower triangle of the (Hermitian) inverse of <c>a</c>, 
		/// overwriting the input factor U or L.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the [i,i] element of the factor U or L is zero, and the inverse could not be computed.</item>
		/// </list></returns>
		int Cpotri(char uplo, int n, ComplexFloat[] a, int lda);

		/// <summary>
		/// Solves a system of linear equations A*X = B with a Hermitian
		/// positive definite matrix A using the Cholesky factorization
		/// <code>A = U**H*U or A = L*L**H</code> computed by CPOTRF.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns
		/// of the matrix <paramref name="b"/>. <c>nrhs &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The triangular factor U or L from the Cholesky factorization
		/// A = U**H*U or A = L*L**H, as computed by CPOTRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>.
		/// On entry, the right hand side matrix <c>b</c>.
		/// On exit, the solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cpotrs(char uplo, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb);

		/// <summary>
		/// Generates an M by N real matrix Q with orthonormal columns,
		/// which is defined as the first N columns of a product of K elementary
		/// reflectors of order M: <code>Q = H(0) H(1) . . . H(k-1)</code>
		/// as returned by CGEQRF.
		/// </summary>
		/// <param name="m">The number of rows of the matrix Q. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix Q. <c>m &gt;= n &gt;= 0</c></param>
		/// <param name="k">The number of elementary reflectors whose product defines the matrix Q. <c>n &gt;= k &gt;= 0</c>.</param>
		/// <param name="a">Dimension LDA by N.
		/// On entry, the i-th column must contain the vector which defines the elementary reflector H(0), for i = 0,2,...,k-1, as
		/// returned by CGEQRF in the first k columns of its array argument <c>a</c>.
		/// On exit, the <parmaref name="m"/> by <parmaref name="n"/> matrix Q.</param>
		/// <param name="lda">The first dimension of the array <parmaref name="a"/> . <c>lda</c> &gt;= max(1,<parmaref name="m"/>).</param>
		/// <param name="tau">Dimension K. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by CGEQRF.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cungqr(int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau);

		/// <summary>
		/// Generates an M by N real matrix Q with orthonormal columns,
		/// which is defined as the first N columns of a product of K elementary
		/// reflectors of order M: <code>Q = H(0) H(1) . . . H(k-1)</code>
		/// as returned by CGEQRF.
		/// </summary>
		/// <param name="m">The number of rows of the matrix Q. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix Q. <c>m &gt;= n &gt;= 0</c></param>
		/// <param name="k">The number of elementary reflectors whose product defines the matrix Q. <c>n &gt;= k &gt;= 0</c>.</param>
		/// <param name="a">Dimension LDA by N.
		/// On entry, the i-th column must contain the vector which defines the elementary reflector H(0), for i = 0,2,...,k-1, as
		/// returned by CGEQRF in the first k columns of its array argument <c>a</c>.
		/// On exit, the <parmaref name="m"/> by <parmaref name="n"/> matrix Q.</param>
		/// <param name="lda">The first dimension of the array <parmaref name="a"/> . <c>lda</c> &gt;= max(1,<parmaref name="m"/>).</param>
		/// <param name="tau">Dimension K. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by CGEQRF.</param>
		/// <param name="work">Work array. The length of <c>work</c> should be at least <paramref name="n"/>*NB,
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <c>work[0]</c> returns the optimal length of <c>work</c> to use.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cungqr(int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);

		/// <summary>
		/// <para>Overwrites the general real M-by-N matrix C with
		/// <pre>             SIDE = 'L'    SIDE = 'R'</pre>
		/// <pre>TRANS = 'N':   Q * C         C * Q</pre>
		/// <pre>TRANS = 'T':   Q**H * C      C * Q**H</pre>																		
		/// where Q is a real orthogonal matrix defined as the product of k elementary reflectors
		/// Q = H(0) H(1) . . . H(k-1) as returned by CGEQRF. Q is of order M if 
		/// SIDE == 'L' and of order N if SIDE == 'R'.</para>
		/// </summary>
		/// <param name="side"><list>
		/// <item>'L': apply Q or Q**H from the Left.</item>
		/// <item>'R': apply Q or Q**H from the Right.</item>
		/// </list></param>
		/// <param name="trans"><list>
		/// <item>'N': No transpose, apply Q;</item>
		/// <item>'T': Transpose, apply Q**H.</item>
		/// </list></param>
		/// <param name="m">The number of rows of the matrix <paramref name="c"/>. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="c"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="k"> The number of elementary reflectors whose product defines the matrix Q.
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="m"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// <item>If <paramref name="side"/> == 'R', <paramref name="n"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// </list></param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="k"/>.
		/// The i-th column must contain the vector which defines the
		/// elementary reflector H(i), for i = 0,2,...,<paramref name="k"/>-1, as returned by
		///	CGEQRF in the first <paramref name="k"/> columns of its array argument <paramref name="a"/>.
		///	<paramref name="a"/> is modified by the routine but restored on exit.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/> .
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <c>lda</c> &gt;= max(1,<paramref name="m"/>).</item>
		/// <item>If <paramref name="side"/> == 'R', <c>lda</c> &gt;= max(1,<paramref name="n"/>).</item>
		/// </list></param>
		/// <param name="tau">Dimension <paramref name="k"/>. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by CGEQRF.</param>
		/// <param name="c">dimension <paramref name="ldc"/> by <paramref name="n"/>. 
		/// On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>c</c>.
		/// On exit, <c>c</c> is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.</param>
		/// <param name="ldc">The leading dimension of the array <paramref name="c"/>.<c>ldc</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cunmqr(char side, char trans, int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc);

		/// <summary>
		/// <para>Overwrites the general real M-by-N matrix C with
		/// <pre>             SIDE = 'L'    SIDE = 'R'</pre>
		/// <pre>TRANS = 'N':   Q * C         C * Q</pre>
		/// <pre>TRANS = 'T':   Q**H * C      C * Q**H</pre>																		
		/// where Q is a real orthogonal matrix defined as the product of k elementary reflectors
		/// Q = H(0) H(1) . . . H(k-1) as returned by CGEQRF. Q is of order M if 
		/// SIDE == 'L' and of order N if SIDE == 'R'.</para>
		/// </summary>
		/// <param name="side"><list>
		/// <item>'L': apply Q or Q**H from the Left.</item>
		/// <item>'R': apply Q or Q**H from the Right.</item>
		/// </list></param>
		/// <param name="trans"><list>
		/// <item>'N': No transpose, apply Q;</item>
		/// <item>'T': Transpose, apply Q**H.</item>
		/// </list></param>
		/// <param name="m">The number of rows of the matrix <paramref name="c"/>. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="c"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="k"> The number of elementary reflectors whose product defines the matrix Q.
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="m"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// <item>If <paramref name="side"/> == 'R', <paramref name="n"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// </list></param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="k"/>.
		/// The i-th column must contain the vector which defines the
		/// elementary reflector H(i), for i = 0,2,...,<paramref name="k"/>-1, as returned by
		///	CGEQRF in the first <paramref name="k"/> columns of its array argument <paramref name="a"/>.
		///	<paramref name="a"/> is modified by the routine but restored on exit.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/> .
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <c>lda</c> &gt;= max(1,<paramref name="m"/>).</item>
		/// <item>If <paramref name="side"/> == 'R', <c>lda</c> &gt;= max(1,<paramref name="n"/>).</item>
		/// </list></param>
		/// <param name="tau">Dimension <paramref name="k"/>. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by CGEQRF.</param>
		/// <param name="c">dimension <paramref name="ldc"/> by <paramref name="n"/>. 
		/// On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>c</c>.
		/// On exit, <c>c</c> is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.</param>
		/// <param name="ldc">The leading dimension of the array <paramref name="c"/>.<c>ldc</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="work">Work array. The length of <c>work</c> should be:
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="n"/> * NB.</item>
		/// <item>if <paramref name="side"/> == 'R', <paramref name="m"/> * NB.</item>
		/// </list>
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <c>work[0]</c> returns the optimal length of <c>work</c> to use.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cunmqr(char side, char trans, int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);

		/// <summary>
		/// Computes the least squares solution to an over-determined system of linear equations, A*X=B, or the minimum norm
		/// solution of an under-determined system, where A is a general rectangular matrix of full rank, using a QR or LQ factorization
		/// of A or underdetermined linear system with full rank matrix.
		/// </summary>
		/// <param name="trans">If <c>trans</c> == 'N': the linear system involves <paramref name="a"/>. If <c>trans</c> == 'T': the linear system involves <paramref name="a"/>'.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m</c> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n</c> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrix <paramref name="b"/>. <c>nrhs</c> &gt;=0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix. On exit, if <paramref name="m"/> >= <paramref name="n"/>, 
		/// <paramref name="a"/> is overwritten by details of its QR factorization as returned by Sgeqrf. Otherwise, <paramref name="a"/> is 
		/// overwritten by details of its LQ factorization as returned by Sgelqf.</param>
		/// <param name="lda">The leading dimension of <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b"> Dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>). On entry, the matrix <c>b</c> of right hand side vectors, stored columnwise. 
		/// b is <paramref name="m"/> by <paramref name="nrhs"/> if <paramref name="trans"/> == 'N', or <paramref name="n"/> by <paramref name="n"/> by <paramref name="nrhs"/>
		/// if <paramref name="trans"/> == 'T'. On exit, <c>b</c> is overwritten by the solution vectors, stored columnwise: 
		/// <list>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="n"/> to <paramref name="m"/>-1 in that column.</item>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &lt; <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &lt;<paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="m"/> to <paramref name="n"/>-1 in that column.</item>
		/// </list></param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zgels(char trans, int m, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb);

		/// <summary>
		/// Computes the least squares solution to an over-determined system of linear equations, A*X=B, or the minimum norm
		/// solution of an under-determined system, where A is a general rectangular matrix of full rank, using a QR or LQ factorization
		/// of A or underdetermined linear system with full rank matrix.
		/// </summary>
		/// <param name="trans">If <c>trans</c> == 'N': the linear system involves <paramref name="a"/>. If <c>trans</c> == 'T': the linear system involves <paramref name="a"/>'.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m</c> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n</c> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrix <paramref name="b"/>. <c>nrhs</c> &gt;=0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix. On exit, if <paramref name="m"/> >= <paramref name="n"/>, 
		/// <paramref name="a"/> is overwritten by details of its QR factorization as returned by Sgeqrf. Otherwise, <paramref name="a"/> is 
		/// overwritten by details of its LQ factorization as returned by Sgelqf.</param>
		/// <param name="lda">The leading dimension of <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b"> Dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>). On entry, the matrix <c>b</c> of right hand side vectors, stored columnwise. 
		/// b is <paramref name="m"/> by <paramref name="nrhs"/> if <paramref name="trans"/> == 'N', or <paramref name="n"/> by <paramref name="n"/> by <paramref name="nrhs"/>
		/// if <paramref name="trans"/> == 'T'. On exit, <c>b</c> is overwritten by the solution vectors, stored columnwise: 
		/// <list>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="n"/> to <paramref name="m"/>-1 in that column.</item>
		/// <item>If <paramref name="trans"/> == 'N' and <paramref name="m"/> &lt; <paramref name="n"/>, rows 0 to <paramref name="n"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &gt;= <paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the minimum norm solution vectors.</item>
		/// <item>If <paramref name="trans"/> == 'T' and <paramref name="m"/> &lt;<paramref name="n"/>, rows 0 to <paramref name="m"/>-1 of <c>b</c> contain the least squares solution vectors. The residual sum of squares for the solution in each column is given by the sum of squares of elements <paramref name="m"/> to <paramref name="n"/>-1 in that column.</item>
		/// </list></param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="work">Work array. On exit, <c>work[0]</c> equals the optimal length the work array should be.
		/// The length of <c>work</c> should be at least max( 1, MN + max( MN, <paramref name="nrhs"/> ) ). For optimal performance,
		/// The length of <c>work</c> should be at least max( 1, MN + max( MN, <paramref name="nrhs"/> )*NB ), where MN = min(<paramref name="m"/>,<paramref name="n"/>) and NB is the optimum block size.
		/// </param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zgels(char trans, int m, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] work);

		/// <summary>
		/// <para>Computes the minimum norm solution to a real linear least squares problem:</para>
		/// <para>Minimize 2-norm(| B - A*X |)</para>
		/// <para>using the singular value decomposition (SVD) of A. A is an M by N matrix which may be rank-deficient.
		/// Several right hand side vectors B and solution vectors X can be handled in a single call. They are stored as the columns of the
		/// M by NRHS right hand side matrix B and the N by NRHS solution matrix X.
		/// The effective rank of A is determined by treating as zero those singular values which are less than rcond times the largest singular value.</para>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <paramref name="a"/>. On exit, the first min(<paramref name="m"/>,n) rows of <paramref name="a"/> 
		/// are overwritten with its right singular vectors, stored rowwise.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>. On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, <paramref name="b"/> is overwritten by the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X. If <paramref name="m"/> &gt;= <paramref name="n"/> and RANK = <paramref name="n"/>, the residual
		/// sum-of-squares for the solution in the i-th column is given	by the sum of squares of elements <paramref name="n"/>:<paramref name="m"/>-1 in that column.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,max(<paramref name="m"/>,<paramref name="n"/>)).</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>) The singular values of <paramref name="a"/> in decreasing order. The condition number of <paramref name="a"/> 
		/// in the 2-norm = <paramref name="s"/>[0]/<paramref name="s"/>[min(<paramref name="m"/>,<paramref name="n"/>)-1].</param>
		/// <param name="rank">The effective rank of A.</param>
		/// <returns> <list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the algorithm for computing the SVD failed to converge. i-th off-diagonal elements of an intermediate
		/// bidiagonal form did not converge to zero.</item>
		/// </list></returns>
		int Zgelss(int m, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, out double[] s, ref int rank);

		/// <summary>
		/// <para>Computes the minimum norm solution to a real linear least squares problem:</para>
		/// <para>Minimize 2-norm(| B - A*X |)</para>
		/// <para>using the singular value decomposition (SVD) of A. A is an M by N matrix which may be rank-deficient.
		/// Several right hand side vectors B and solution vectors X can be handled in a single call. They are stored as the columns of the
		/// M by NRHS right hand side matrix B and the N by NRHS solution matrix X.
		/// The effective rank of A is determined by treating as zero those singular values which are less than rcond times the largest singular value.</para>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns of the matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <paramref name="a"/>. On exit, the first min(<paramref name="m"/>,n) rows of <paramref name="a"/> 
		/// are overwritten with its right singular vectors, stored rowwise.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>. On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, <paramref name="b"/> is overwritten by the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X. If <paramref name="m"/> &gt;= <paramref name="n"/> and RANK = <paramref name="n"/>, the residual
		/// sum-of-squares for the solution in the i-th column is given	by the sum of squares of elements <paramref name="n"/>:<paramref name="m"/>-1 in that column.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <paramref name="ldb"/> &gt;= max(1,max(<paramref name="m"/>,<paramref name="n"/>)).</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>) The singular values of <paramref name="a"/> in decreasing order. The condition number of <paramref name="a"/> 
		/// in the 2-norm = S[0]/S[min(<paramref name="m"/>,<paramref name="n"/>)-1].</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>. Singular values <paramref name="s"/>[i] &lt;= <c>rcond</c>*<paramref name="s"/>[0] are treated as zero.
		/// If <c>rcond</c> &lt; 0, machine precision is used instead.</param>
		/// <param name="rank">The effective rank of A, i.e., the number of singular values which are greater than <paramref name="rcond"/>*<paramref name="s"/>[0].</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.
		/// The length of <c>work</c> should be at least 2*min(<paramref name="m"/>,<paramref name="n"/>) + max(<paramref name="m"/>,<paramref name="n"/>,<paramref name="nrhs"/>).
		/// </param>
		/// <param name="rwork">Dimension 5*min(<paramref name="m"/>,<paramref name="n"/>)</param>
		/// <returns> <list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the algorithm for computing the SVD failed to converge. i-th off-diagonal elements of an intermediate
		/// bidiagonal form did not converge to zero.</item>
		/// </list></returns>
		int Zgelss(int m, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, out double[] s, double rcond, ref int rank, ComplexDouble[] work, double[] rwork);

		/// <summary>
		/// <para>Computes the minimum-norm solution to a real linear least squares problem:</para>
		/// <para>minimize || A * X - B ||</para>
		/// <para>using a complete orthogonal factorization of A. A is an M by N
		/// matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be
		/// handled in a single call; they are stored as the columns of the M by NRHS right hand side matrix B 
		/// and the N by NRHS solution matrix X. The routine first computes a QR factorization with column pivoting:
		/// <code>
		/// A * P = Q * [ R00 R01 ]
		///             [ 0   R11 ]
		///</code>
		/// with R11 defined as the largest leading submatrix whose estimated
		/// condition number is less than 1/RCOND. The order of R11, RANK,
		/// is the effective rank of A.</para>
		/// <para>Then, R22 is considered to be negligible, and R12 is annihilated
		/// by orthogonal transformations from the right, arriving at the complete orthogonal factorization:
		/// <code>
		/// A * P = Q * [ T00 0 ] * Z
		///             [ 0   0 ]
		/// </code>
		/// The minimum-norm solution is then
		/// <code>
		/// X = P * Z' [ inv(T00)*Q0'*B ]
		///            [        0       ]
		/// </code>
		/// where Q0 consists of the first RANK columns of Q.</para>
		/// This routine is basically identical to the original xGELSX except three differences:
		/// <list>
		/// <item>The call to the subroutine xGEQPF has been substituted by the
		/// the call to the subroutine xGEQP3. This subroutine is a Blas-3
		/// version of the QR factorization with column pivoting.</item>
		/// <item>Matrix B (the right hand side) is updated with Blas-3.</item>
		/// <item>The permutation of matrix B (the right hand side) is faster and more simple.</item>
		/// </list>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of
		/// columns of matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, <c>a</c> has been overwritten by details of its complete orthogonal factorization.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>)
		/// On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="jpvt">On entry, if <c>jpvt[i] != 0</c>, the i-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>P, otherwise column i is a free column.
		/// On exit, if <c>jpvt[i] = k</c>, then the i-th column of <paramref name="a"/>P
		/// was the k-th column of <paramref name="a"/>.</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>, which
		/// is defined as the order of the largest leading triangular
		/// submatrix R00 in the QR factorization with pivoting of <paramref name="a"/>,
		/// whose estimated condition number &lt; <c>1/rcond</c>.</param>
		/// <param name="rank"> The effective rank of <paramref name="a"/>, i.e., the order of the submatrix
		/// R00. This is the same as the order of the submatrix T00
		/// in the complete orthogonal factorization of <paramref name="a"/>.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zgelsy(int m, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, int[] jpvt, double rcond, ref int rank);

		/// <summary>
		/// <para>Computes the minimum-norm solution to a real linear least squares problem:</para>
		/// <para>minimize || A * X - B ||</para>
		/// <para>using a complete orthogonal factorization of A. A is an M by N
		/// matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be
		/// handled in a single call; they are stored as the columns of the M by NRHS right hand side matrix B 
		/// and the N by NRHS solution matrix X. The routine first computes a QR factorization with column pivoting:
		/// <code>
		/// A * P = Q * [ R00 R01 ]
		///             [ 0   R11 ]
		/// </code>
		/// with R11 defined as the largest leading submatrix whose estimated
		/// condition number is less than 1/RCOND. The order of R11, RANK,
		/// is the effective rank of A.</para>
		/// <para>Then, R22 is considered to be negligible, and R12 is annihilated
		/// by orthogonal transformations from the right, arriving at the complete orthogonal factorization:
		/// <code>
		/// A * P = Q * [ T00 0 ] * Z
		///             [ 0   0 ]
		/// </code>
		/// The minimum-norm solution is then
		/// <code>
		/// X = P * Z' [ inv(T00)*Q0'*B ]
		///            [        0       ]
		/// </code>
		/// where Q0 consists of the first RANK columns of Q.</para>
		/// This routine is basically identical to the original xGELSX except three differences:
		/// <list>
		/// <item>The call to the subroutine xGEQPF has been substituted by the
		/// the call to the subroutine xGEQP3. This subroutine is a Blas-3
		/// version of the QR factorization with column pivoting.</item>
		/// <item>Matrix B (the right hand side) is updated with Blas-3.</item>
		/// <item>The permutation of matrix B (the right hand side) is faster and more simple.</item>
		/// </list>
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of
		/// columns of matrices <paramref name="b"/> and X. <paramref name="nrhs"/> &gt;= 0.</param>
		/// <param name="a">On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, <c>a</c> has been overwritten by details of its complete orthogonal factorization.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="b">dimension (<paramref name="ldb"/>,<paramref name="nrhs"/>)
		/// On entry, the <paramref name="m"/> by <paramref name="nrhs"/> right hand side matrix <paramref name="b"/>.
		/// On exit, the <paramref name="n"/> by <paramref name="nrhs"/> solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="jpvt">On entry, if <c>jpvt[i] != 0</c>, the i-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>P, otherwise column i is a free column.
		/// On exit, if <c>jpvt[i] = k</c>, then the i-th column of <paramref name="a"/>P
		/// was the k-th column of <paramref name="a"/>.</param>
		/// <param name="rcond"><c>rcond</c> is used to determine the effective rank of <paramref name="a"/>, which
		/// is defined as the order of the largest leading triangular
		/// submatrix R00 in the QR factorization with pivoting of <paramref name="a"/>,
		/// whose estimated condition number &lt; <c>1/rcond</c>.</param>
		/// <param name="rank"> The effective rank of <paramref name="a"/>, i.e., the order of the submatrix
		/// R00. This is the same as the order of the submatrix T00
		/// in the complete orthogonal factorization of <paramref name="a"/>.</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.
		/// The length of <c>work</c> should be at least MN + MAX( 2*MN, NB*(<paramref name="n"/>+1), MN+MN*NB, MN+NB*<paramref name="nrhs"/> ) 
		/// where MN = min( <paramref name="m"/>, <paramref name="n"/> ) and NB is an upper bound on the blocksize returned by ILAENV
		/// for the routines ZGEQP3, ZTZRZF, ZTZRQF, ZUNMQR, and ZUNMRZ.</param>
		/// <param name="rwork">Dimension 2*<paramref name="n"/></param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zgelsy(int m, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, int[] jpvt, double rcond, ref int rank, ComplexDouble[] work, double[] rwork);

		/// <summary>
		/// Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, the upper triangle of the array contains the
		/// min(<paramref name="m"/>,<paramref name="n"/>) by <paramref name="n"/> upper trapezoidal matrix R. The elements below
		/// the diagonal, together with the array <paramref name="tau"/>, represent the
		/// unitary matrix Q as a product of min(<paramref name="m"/>,<paramref name="n"/>) elementary
		/// reflectors.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="jpvt">Dimension <paramref name="n"/>.
		/// On entry, if <c>jpvt[j] != 0</c>, the j-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>*P (a leading column); if <c>jpvt[j] == 0</c>,
		/// the j-th column of <paramref name="a"/> is a free column.
		/// On exit, if <c>jpvt[j] == k</c>, then the j-th column of <paramref name="a"/>*P was the
		/// the k-th column of <paramref name="a"/>.</param>
		/// <param name="tau">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The scalar factors of the elementary reflectors.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zgeqp3(int m, int n, ComplexDouble[] a, int lda, int[] jpvt, ComplexDouble[] tau);

		/// <summary>
		/// Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit, the upper triangle of the array contains the
		/// min(<paramref name="m"/>,<paramref name="n"/>) by <paramref name="n"/> upper trapezoidal matrix R. The elements below
		/// the diagonal, together with the array <paramref name="tau"/>, represent the
		/// unitary matrix Q as a product of min(<paramref name="m"/>,<paramref name="n"/>) elementary
		/// reflectors.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="jpvt">Dimension <paramref name="n"/>.
		/// On entry, if <c>jpvt[j] != 0</c>, the j-th column of <paramref name="a"/> is permuted
		/// to the front of <paramref name="a"/>*P (a leading column); if <c>jpvt[j] == 0</c>,
		/// the j-th column of <paramref name="a"/> is a free column.
		/// On exit, if <c>jpvt[j] == k</c>, then the j-th column of <paramref name="a"/>*P was the
		/// the k-th column of <paramref name="a"/>.</param>
		/// <param name="tau">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The scalar factors of the elementary reflectors.</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use. 
		/// The length of <c>work</c> should be at least<paramref name="n"/>+1.
		/// For optimal performance the length of <c>work</c> should be at least( <paramref name="n"/>+1 )*NB, where NB is the optimal blocksize.</param>
		/// <param name="rwork">Dimension 2*<paramref name="n"/></param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zgeqp3(int m, int n, ComplexDouble[] a, int lda, int[] jpvt, ComplexDouble[] tau, ComplexDouble[] work, double[] rwork);

		/// <summary>
		/// Computes an LU factorization of a general M by N matrix A
		/// using partial pivoting with row interchanges. 
		/// The factorization has the form A = P * L * U
		/// where P is a permutation matrix, L is lower triangular with unit
		/// diagonal elements (lower trapezoidal if m &gt; n), and U is upper
		/// triangular (upper trapezoidal if m &lt; n).
		/// This is the right-looking Level 3 BLAS version of the algorithm.
		/// </summary>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimensions <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/>-by-<paramref name="n"/> matrix to be factored.
		/// On exit, the factors L and U from the factorization
		/// A = P*L*U. The unit diagonal elements of L are not stored.</param>
		/// <param name="lda"> The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="ipiv">Dimension min(<paramref name="m"/>,<paramref name="n"/>).
		/// The pivot indices. for 0 &lt;= i &lt;= min(<paramref name="m"/>,<paramref name="n"/>), row i of the matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <returns>
		/// <list> 
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: U[i,i] is exactly zero. The factorization has been completed, but the factor U is exactly
		///	singular, and division by zero will occur if it is used
		/// to solve a system of equations.</item>
		/// </list></returns>
		int Zgetrf(int m, int n, ComplexDouble[] a, int lda, out int[] ipiv);

		/// <summary>
		/// Computes the inverse of a matrix using the LU factorization
		/// computed by ZGETRF. This method inverts U and then computes 
		/// inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
		/// </summary>
		/// <param name="n"> The order of the matrix <parmaref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <parmaref name="lda"/> by <parmaref name="n"/>. On entry, the factors L and U from the factorization
		/// A = P*L*U as computed by ZGETRF.
		/// On exit, the inverse of the original matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <parmaref name="a"/>. <c>lda</c> &gt;= max(1,<parmaref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from ZGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value</item>
		/// <item>&gt; 0: U[i,i] is exactly zero; the matrix is
		/// singular and its inverse could not be computed.</item>
		/// </list></returns>
		int Zgetri(int n, ComplexDouble[] a, int lda, int[] ipiv);

		/// <summary>
		/// Computes the inverse of a matrix using the LU factorization
		/// computed by ZGETRF. This method inverts U and then computes 
		/// inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
		/// </summary>
		/// <param name="n"> The order of the matrix <parmaref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <parmaref name="lda"/> by <parmaref name="n"/>. On entry, the factors L and U from the factorization
		/// A = P*L*U as computed by ZGETRF.
		/// On exit, the inverse of the original matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <parmaref name="a"/>. <c>lda</c> &gt;= max(1,<parmaref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from ZGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <param name="work">Work array. The length of <c>work</c> should be at least <paramref name="n"/>*NB,
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value</item>
		/// <item>&gt; 0: U[i,i] is exactly zero; the matrix is
		/// singular and its inverse could not be computed.</item>
		/// </list></returns>
		int Zgetri(int n, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] work);

		/// <summary>
		/// Solves a system of linear equations <code>A * X = B, A**T * X = B, or A**H * X = B</code>
		/// with a general N by N matrix A using the LU factorization computed by ZGETRF.
		/// </summary>
		/// <param name="trans"> Specifies the form of the system of equations:
		/// <list>
		/// <item>'N': A * X = B (No transpose)</item>
		/// <item>'T': A**T * X = B (Transpose)</item>
		/// <item>'C': A**H * X = B (Conjugate transpose)</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns
		/// of the matrix <paramref name="b"/>. <c>nrhs &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by ZGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="ipiv">Dimension <parmaref name="n"/>. The pivot indices from ZGETRF; for 0 &lt;= i &lt;= <parmaref name="n"/>-1, row i of the
		/// matrix was interchanged with row <c>ipiv[i]</c>.</param>
		/// <param name="b">Dimension <parmaref name="ldb"/> by <parmaref name="nrhs"/>.
		/// On entry, the right hand side matrix <c>b</c>.
		/// On exit, the solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zgetrs(char trans, int n, int nrhs, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] b, int ldb);

		/// <summary>
		/// Computes the Cholesky factorization of a Hermitian
		/// positive definite matrix A.
		/// The factorization has the form 
		/// <code>
		/// A = U**H * U, if UPLO == 'U' 
		/// A = L * L**H, if UPLO == 'L'
		/// </code>
		/// where U is an upper triangular matrix and L is lower triangular.
		/// This is the block version of the algorithm, calling Level 3 BLAS.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// On entry, the Hermitian matrix <c>a</c>. 
		/// If <paramref name="uplo"/> == 'U', the leading <paramref name="n"/> by <paramref name="n"/> upper triangular part of <c>a</c>
		/// contains the upper triangular part of the matrix <c>a</c>, and the strictly lower triangular part of <c>a</c> is not referenced.
		/// If <paramref name="uplo"/> == 'L', the leading <paramref name="n"/> by <paramref name="n"/> lower triangular part of <c>a</c>
		/// contains the lower triangular part of the matrix <c>a</c>, and the strictly upper triangular part of <c>a</c> is not referenced.
		/// On exit, the factor U or L from the Cholesky factorization <c>A = U**H*U or A = L*L**H</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the leading minor of order i is not positive definite, and the factorization could not be completed.</item>
		/// </list></returns>
		int Zpotrf(char uplo, int n, ComplexDouble[] a, int lda);

		/// <summary>
		/// Computes the inverse of a Hermitian positive definite
		/// matrix A using the Cholesky factorization A = U**H*U or A = L*L**H
		/// computed by ZPOTRF.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// On entry, the triangular factor U or L from the Cholesky
		/// factorization A = U**H*U or A = L*L**H, as computed by ZPOTRF.
		/// On exit, the upper or lower triangle of the (Hermitian) inverse of <c>a</c>, 
		/// overwriting the input factor U or L.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns><list>
		/// <item>0: successful exit</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: the [i,i] element of the factor U or L is zero, and the inverse could not be computed.</item>
		/// </list></returns>
		int Zpotri(char uplo, int n, ComplexDouble[] a, int lda);

		/// <summary>
		/// Solves a system of linear equations A*X = B with a Hermitian
		/// positive definite matrix A using the Cholesky factorization
		/// <code>A = U**H*U or A = L*L**H</code> computed by ZPOTRF.
		/// </summary>
		/// <param name="uplo"><list>
		/// <item>'U': Upper triangle of A is stored.</item>
		/// <item>'L': Lower triangle of A is stored.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="nrhs">The number of right hand sides, i.e., the number of columns
		/// of the matrix <paramref name="b"/>. <c>nrhs &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The triangular factor U or L from the Cholesky factorization
		/// A = U**H*U or A = L*L**H, as computed by ZPOTRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="b">Dimension <paramref name="ldb"/> by <paramref name="nrhs"/>.
		/// On entry, the right hand side matrix <c>b</c>.
		/// On exit, the solution matrix X.</param>
		/// <param name="ldb">The leading dimension of the array <paramref name="b"/>. <c>ldb</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zpotrs(char uplo, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb);

		/// <summary>
		/// Generates an M by N real matrix Q with orthonormal columns,
		/// which is defined as the first N columns of a product of K elementary
		/// reflectors of order M: <code>Q = H(0) H(1) . . . H(k-1)</code>
		/// as returned by ZGEQRF.
		/// </summary>
		/// <param name="m">The number of rows of the matrix Q. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix Q. <c>m &gt;= n &gt;= 0</c></param>
		/// <param name="k">The number of elementary reflectors whose product defines the matrix Q. <c>n &gt;= k &gt;= 0</c>.</param>
		/// <param name="a">Dimension LDA by N.
		/// On entry, the i-th column must contain the vector which defines the elementary reflector H(0), for i = 0,2,...,k-1, as
		/// returned by ZGEQRF in the first k columns of its array argument <c>a</c>.
		/// On exit, the <parmaref name="m"/> by <parmaref name="n"/> matrix Q.</param>
		/// <param name="lda">The first dimension of the array <parmaref name="a"/> . <c>lda</c> &gt;= max(1,<parmaref name="m"/>).</param>
		/// <param name="tau">Dimension K. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by ZGEQRF.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zungqr(int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau);

		/// <summary>
		/// Generates an M by N real matrix Q with orthonormal columns,
		/// which is defined as the first N columns of a product of K elementary
		/// reflectors of order M: <code>Q = H(0) H(1) . . . H(k-1)</code>
		/// as returned by ZGEQRF.
		/// </summary>
		/// <param name="m">The number of rows of the matrix Q. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix Q. <c>m &gt;= n &gt;= 0</c></param>
		/// <param name="k">The number of elementary reflectors whose product defines the matrix Q. <c>n &gt;= k &gt;= 0</c>.</param>
		/// <param name="a">Dimension LDA by N.
		/// On entry, the i-th column must contain the vector which defines the elementary reflector H(0), for i = 0,2,...,k-1, as
		/// returned by ZGEQRF in the first k columns of its array argument <c>a</c>.
		/// On exit, the <parmaref name="m"/> by <parmaref name="n"/> matrix Q.</param>
		/// <param name="lda">The first dimension of the array <parmaref name="a"/> . <c>lda</c> &gt;= max(1,<parmaref name="m"/>).</param>
		/// <param name="tau">Dimension K. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by ZGEQRF.</param>
		/// <param name="work">Work array. The length of <c>work</c> should be at least <paramref name="n"/>*NB,
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <c>work[0]</c> returns the optimal length of <c>work</c> to use.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zungqr(int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);

		/// <summary>
		/// <para>Overwrites the general real M-by-N matrix C with
		/// <pre>             SIDE = 'L'    SIDE = 'R'</pre>
		/// <pre>TRANS = 'N':   Q * C         C * Q</pre>
		/// <pre>TRANS = 'T':   Q**H * C      C * Q**H</pre>																				
		/// where Q is a real orthogonal matrix defined as the product of k elementary reflectors
		/// Q = H(0) H(1) . . . H(k-1) as returned by ZGEQRF. Q is of order M if 
		/// SIDE == 'L' and of order N if SIDE == 'R'.</para>
		/// </summary>
		/// <param name="side"><list>
		/// <item>'L': apply Q or Q**H from the Left.</item>
		/// <item>'R': apply Q or Q**H from the Right.</item>
		/// </list></param>
		/// <param name="trans"><list>
		/// <item>'N': No transpose, apply Q;</item>
		/// <item>'T': Transpose, apply Q**H.</item>
		/// </list></param>
		/// <param name="m">The number of rows of the matrix <paramref name="c"/>. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="c"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="k"> The number of elementary reflectors whose product defines the matrix Q.
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="m"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// <item>If <paramref name="side"/> == 'R', <paramref name="n"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// </list></param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="k"/>.
		/// The i-th column must contain the vector which defines the
		/// elementary reflector H(i), for i = 0,2,...,<paramref name="k"/>-1, as returned by
		///	ZGEQRF in the first <paramref name="k"/> columns of its array argument <paramref name="a"/>.
		///	<paramref name="a"/> is modified by the routine but restored on exit.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/> .
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <c>lda</c> &gt;= max(1,<paramref name="m"/>).</item>
		/// <item>If <paramref name="side"/> == 'R', <c>lda</c> &gt;= max(1,<paramref name="n"/>).</item>
		/// </list></param>
		/// <param name="tau">Dimension <paramref name="k"/>. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by ZGEQRF.</param>
		/// <param name="c">dimension <paramref name="ldc"/> by <paramref name="n"/>. 
		/// On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>c</c>.
		/// On exit, <c>c</c> is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.</param>
		/// <param name="ldc">The leading dimension of the array <paramref name="c"/>.<c>ldc</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zunmqr(char side, char trans, int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc);

		/// <summary>
		/// <para>Overwrites the general real M-by-N matrix C with
		/// <pre>             SIDE = 'L'    SIDE = 'R'</pre>
		/// <pre>TRANS = 'N':   Q * C         C * Q</pre>
		/// <pre>TRANS = 'T':   Q**H * C      C * Q**H</pre>																			
		/// where Q is a real orthogonal matrix defined as the product of k elementary reflectors
		/// Q = H(0) H(1) . . . H(k-1) as returned by ZGEQRF. Q is of order M if 
		/// SIDE == 'L' and of order N if SIDE == 'R'.</para>
		/// </summary>
		/// <param name="side"><list>
		/// <item>'L': apply Q or Q**H from the Left.</item>
		/// <item>'R': apply Q or Q**H from the Right.</item>
		/// </list></param>
		/// <param name="trans"><list>
		/// <item>'N': No transpose, apply Q;</item>
		/// <item>'T': Transpose, apply Q**H.</item>
		/// </list></param>
		/// <param name="m">The number of rows of the matrix <paramref name="c"/>. <c>m &gt;= 0</c>.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="c"/>. <c>n &gt;= 0</c>.</param>
		/// <param name="k"> The number of elementary reflectors whose product defines the matrix Q.
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="m"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// <item>If <paramref name="side"/> == 'R', <paramref name="n"/> &gt;= <paramref name="k"/> &gt;= 0.</item>
		/// </list></param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="k"/>.
		/// The i-th column must contain the vector which defines the
		/// elementary reflector H(i), for i = 0,2,...,<paramref name="k"/>-1, as returned by
		///	ZGEQRF in the first <paramref name="k"/> columns of its array argument <paramref name="a"/>.
		///	<paramref name="a"/> is modified by the routine but restored on exit.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/> .
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <c>lda</c> &gt;= max(1,<paramref name="m"/>).</item>
		/// <item>If <paramref name="side"/> == 'R', <c>lda</c> &gt;= max(1,<paramref name="n"/>).</item>
		/// </list></param>
		/// <param name="tau">Dimension <paramref name="k"/>. <c>tau[i]</c> must contain the scalar factor of the elementary
		/// reflector H(i), as returned by ZGEQRF.</param>
		/// <param name="c">dimension <paramref name="ldc"/> by <paramref name="n"/>. 
		/// On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>c</c>.
		/// On exit, <c>c</c> is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.</param>
		/// <param name="ldc">The leading dimension of the array <paramref name="c"/>.<c>ldc</c> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="work">Work array. The length of <c>work</c> should be:
		/// <list>
		/// <item>If <paramref name="side"/> == 'L', <paramref name="n"/> * NB.</item>
		/// <item>if <paramref name="side"/> == 'R', <paramref name="m"/> * NB.</item>
		/// </list>
		/// where NB is the optimal blocksize returned by ILAENV.
		/// On exit, <c>work[0]</c> returns the optimal length of <c>work</c> to use.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zunmqr(char side, char trans, int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);

		/// <summary>
		/// Computes the singular value decomposition (SVD) of a complex
		/// M by N matrix A, optionally computing the left and/or right singular
		/// vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V)
		/// where SIGMA is an M by N matrix which is zero except for its
		/// min(m,n) diagonal elements, U is an M by M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA
		/// are the singular values of A. They are real and non-negative, and
		/// are returned in descending order. The first min(m,n) columns of
		/// U and V are the left and right singular vectors of A.
		/// Note that the routine returns V**H, not V.
		/// </summary>
		/// <param name="jobu">
		/// Specifies options for computing all or part of the matrix <paramref name="u"/>:
		/// <list>
		/// <item> = '<paramref name="a"/>': all <paramref name="m"/> columns of <paramref name="u"/> are returned in array <paramref name="u"/>.</item>
		/// <item> = '<paramref name="s"/>': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are returned in the array <paramref name="u"/>.</item>
		/// <item> = 'O': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item> = '<paramref name="n"/>': no columns of <paramref name="u"/> (no left singular vectors) are computed. </item>
		/// </list>
		/// </param>
		/// <param name="jobvt">
		/// Specifies options for computing all or part of the matrix V**T:
		/// <list>
		/// <item>'<paramref name="a"/>': all <paramref name="n"/> rows of V**T are returned in the array <paramref name="vt"/>.</item>
		/// <item>'<paramref name="s"/>': the first min(m,n) rows of V**T (the right singular vectors) are returned in the array <paramref name="vt"/>.</item>
		/// <item>'O': the first min(m,n) rows of V**T (the right singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item>'<paramref name="n"/>': no rows of V**T (no right singular vectors) are computed.</item>
		/// </list>
		/// </param>
		/// <param name="m">The number of rows of the input matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the input matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit:<list>
		/// <item>if <paramref name="jobu"/> == 'O', <c>a</c> is overwritten with the first min(m,n) columns of <paramref name="u"/> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobvt"/> == 'O', <c>a</c> is overwritten with the first min(m,n)rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>if <paramref name="jobu"/> != 'O' and <paramref name="jobvt"/> != 'O', the contents of <c>a</c> are destroyed.</item>
		/// </list></param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The singular values of <paramref name="a"/>, sorted so that <c>s[i] &gt;= s[i+1]</c>.</param>
		/// <param name="u">Dimension <paramref name="ldu"/> by UCOL, <paramref name="ldu"/> by <paramref name="m"/> if <paramref name="jobu"/> = '<paramref name="a"/>', or <paramref name="ldu"/> by min(<paramref name="m"/>,<paramref name="n"/>) if <paramref name="jobu"/> = '<paramref name="s"/>'.
		/// <list>
		/// <item>If <paramref name="jobu"/> == '<paramref name="a"/>', <c>u</c> contains the <paramref name="m"/> by <paramref name="m"/> orthogonal matrix <c>u</c>.</item>
		/// <item>If <paramref name="jobu"/> == '<paramref name="s"/>', <c>u</c> contains the first min(m,n) columns of <c>u</c> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobu"/> == '<paramref name="n"/>' or 'O', <c>u</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldu">The leading dimension of the array <paramref name="u"/>. <c>ldu &gt;= 1</c>. If <paramref name="jobu"/> = '<paramref name="s"/>' or '<paramref name="a"/>', <c>ldu &gt;= <paramref name="m"/></c>.</param>
		/// <param name="vt">Dimension <paramref name="ldvt"/> by <paramref name="n"/>.
		/// <list>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="a"/>', <c>vt</c> contains the <paramref name="n"/> by <paramref name="n"/> orthogonal matrix V**T.</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="s"/>', <c>vt</c> contains the first min(m,n) rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="n"/>' or 'O', <c>vt</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldvt">The leading dimension of the array <paramref name="vt"/>. <c>ldvt &gt;= 1</c>. If <paramref name="jobvt"/> == '<paramref name="a"/>', 
		/// <c>ldvt &gt;= <paramref name="n"/></c>; if <paramref name="jobvt"/> == '<paramref name="s"/>', <c><paramref name="ldvt"/> &gt;= min(<paramref name="m"/>,<paramref name="n"/>)</c>.</param>
		/// <returns><list>
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: if CBDSQR did not converge, specifies how many
		/// superdiagonals of an intermediate bidiagonal form B
		/// did not converge to zero.</item>
		/// </list></returns>
		/// <remarks><paramref name="jobvt"/> and <paramref name="jobu"/> cannot both be 'O'.</remarks>
		int Cgesvd(char jobu, char jobvt, int m, int n, ComplexFloat[] a, int lda, float[] s, ComplexFloat[] u, int ldu, ComplexFloat[] vt, int ldvt);

		/// <summary>
		/// Computes the singular value decomposition (SVD) of a complex
		/// M by N matrix A, optionally computing the left and/or right singular
		/// vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V)
		/// where SIGMA is an M by N matrix which is zero except for its
		/// min(m,n) diagonal elements, U is an M by M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA
		/// are the singular values of A. They are real and non-negative, and
		/// are returned in descending order. The first min(m,n) columns of
		/// U and V are the left and right singular vectors of A.
		/// Note that the routine returns V**H, not V.
		/// </summary>
		/// <param name="jobu">
		/// Specifies options for computing all or part of the matrix <paramref name="u"/>:
		/// <list>
		/// <item> = '<paramref name="a"/>': all <paramref name="m"/> columns of <paramref name="u"/> are returned in array <paramref name="u"/>.</item>
		/// <item> = '<paramref name="s"/>': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are returned in the array <paramref name="u"/>.</item>
		/// <item> = 'O': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item> = '<paramref name="n"/>': no columns of <paramref name="u"/> (no left singular vectors) are computed. </item>
		/// </list>
		/// </param>
		/// <param name="jobvt">
		/// Specifies options for computing all or part of the matrix V**T:
		/// <list>
		/// <item>'<paramref name="a"/>': all <paramref name="n"/> rows of V**T are returned in the array <paramref name="vt"/>.</item>
		/// <item>'<paramref name="s"/>': the first min(m,n) rows of V**T (the right singular vectors) are returned in the array <paramref name="vt"/>.</item>
		/// <item>'O': the first min(m,n) rows of V**T (the right singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item>'<paramref name="n"/>': no rows of V**T (no right singular vectors) are computed.</item>
		/// </list>
		/// </param>
		/// <param name="m">The number of rows of the input matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the input matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit:<list>
		/// <item>if <paramref name="jobu"/> == 'O', <c>a</c> is overwritten with the first min(m,n) columns of <paramref name="u"/> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobvt"/> == 'O', <c>a</c> is overwritten with the first min(m,n)rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>if <paramref name="jobu"/> != 'O' and <paramref name="jobvt"/> != 'O', the contents of <c>a</c> are destroyed.</item>
		/// </list></param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The singular values of <paramref name="a"/>, sorted so that <c>s[i] &gt;= s[i+1]</c>.</param>
		/// <param name="u">Dimension <paramref name="ldu"/> by UCOL, <paramref name="ldu"/> by <paramref name="m"/> if <paramref name="jobu"/> = '<paramref name="a"/>', or <paramref name="ldu"/> by min(<paramref name="m"/>,<paramref name="n"/>) if <paramref name="jobu"/> = '<paramref name="s"/>'.
		/// <list>
		/// <item>If <paramref name="jobu"/> == '<paramref name="a"/>', <c>u</c> contains the <paramref name="m"/> by <paramref name="m"/> orthogonal matrix <c>u</c>.</item>
		/// <item>If <paramref name="jobu"/> == '<paramref name="s"/>', <c>u</c> contains the first min(m,n) columns of <c>u</c> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobu"/> == '<paramref name="n"/>' or 'O', <c>u</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldu">The leading dimension of the array <paramref name="u"/>. <c>ldu &gt;= 1</c>. If <paramref name="jobu"/> = '<paramref name="s"/>' or '<paramref name="a"/>', <c>ldu &gt;= <paramref name="m"/></c>.</param>
		/// <param name="vt">Dimension <paramref name="ldvt"/> by <paramref name="n"/>.
		/// <list>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="a"/>', <c>vt</c> contains the <paramref name="n"/> by <paramref name="n"/> orthogonal matrix V**T.</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="s"/>', <c>vt</c> contains the first min(m,n) rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="n"/>' or 'O', <c>vt</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldvt">The leading dimension of the array <paramref name="vt"/>. <c>ldvt &gt;= 1</c>. If <paramref name="jobvt"/> == '<paramref name="a"/>', 
		/// <c>ldvt &gt;= <paramref name="n"/></c>; if <paramref name="jobvt"/> == '<paramref name="s"/>', <c><paramref name="ldvt"/> &gt;= min(<paramref name="m"/>,<paramref name="n"/>)</c>.</param>
		/// <returns><list>
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: if ZBDSQR did not converge, specifies how many
		/// superdiagonals of an intermediate bidiagonal form B
		/// did not converge to zero.</item>
		/// </list></returns>
		/// <remarks><paramref name="jobvt"/> and <paramref name="jobu"/> cannot both be 'O'.</remarks>
		int Zgesvd(char jobu, char jobvt, int m, int n, ComplexDouble[] a, int lda, double[] s, ComplexDouble[] u, int ldu, ComplexDouble[] vt, int ldvt);

		/// <summary>
		/// Computes the singular value decomposition (SVD) of a complex
		/// M by N matrix A, optionally computing the left and/or right singular
		/// vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V)
		/// where SIGMA is an M by N matrix which is zero except for its
		/// min(m,n) diagonal elements, U is an M by M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA
		/// are the singular values of A. They are real and non-negative, and
		/// are returned in descending order. The first min(m,n) columns of
		/// U and V are the left and right singular vectors of A.
		/// Note that the routine returns V**H, not V.
		/// </summary>
		/// <param name="jobu">
		/// Specifies options for computing all or part of the matrix <paramref name="u"/>:
		/// <list>
		/// <item> = '<paramref name="a"/>': all <paramref name="m"/> columns of <paramref name="u"/> are returned in array <paramref name="u"/>.</item>
		/// <item> = '<paramref name="s"/>': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are returned in the array <paramref name="u"/>.</item>
		/// <item> = 'O': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item> = '<paramref name="n"/>': no columns of <paramref name="u"/> (no left singular vectors) are computed. </item>
		/// </list>
		/// </param>
		/// <param name="jobvt">
		/// Specifies options for computing all or part of the matrix V**T:
		/// <list>
		/// <item>'<paramref name="a"/>': all <paramref name="n"/> rows of V**T are returned in the array <paramref name="vt"/>.</item>
		/// <item>'<paramref name="s"/>': the first min(m,n) rows of V**T (the right singular vectors) are returned in the array <paramref name="vt"/>.</item>
		/// <item>'O': the first min(m,n) rows of V**T (the right singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item>'<paramref name="n"/>': no rows of V**T (no right singular vectors) are computed.</item>
		/// </list>
		/// </param>
		/// <param name="m">The number of rows of the input matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the input matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit:<list>
		/// <item>if <paramref name="jobu"/> == 'O', <c>a</c> is overwritten with the first min(m,n) columns of <paramref name="u"/> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobvt"/> == 'O', <c>a</c> is overwritten with the first min(m,n)rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>if <paramref name="jobu"/> != 'O' and <paramref name="jobvt"/> != 'O', the contents of <c>a</c> are destroyed.</item>
		/// </list></param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The singular values of <paramref name="a"/>, sorted so that <c>s[i] &gt;= s[i+1]</c>.</param>
		/// <param name="u">Dimension <paramref name="ldu"/> by UCOL, <paramref name="ldu"/> by <paramref name="m"/> if <paramref name="jobu"/> = '<paramref name="a"/>', or <paramref name="ldu"/> by min(<paramref name="m"/>,<paramref name="n"/>) if <paramref name="jobu"/> = '<paramref name="s"/>'.
		/// <list>
		/// <item>If <paramref name="jobu"/> == '<paramref name="a"/>', <c>u</c> contains the <paramref name="m"/> by <paramref name="m"/> orthogonal matrix <c>u</c>.</item>
		/// <item>If <paramref name="jobu"/> == '<paramref name="s"/>', <c>u</c> contains the first min(m,n) columns of <c>u</c> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobu"/> == '<paramref name="n"/>' or 'O', <c>u</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldu">The leading dimension of the array <paramref name="u"/>. <c>ldu &gt;= 1</c>. If <paramref name="jobu"/> = '<paramref name="s"/>' or '<paramref name="a"/>', <c>ldu &gt;= <paramref name="m"/></c>.</param>
		/// <param name="vt">Dimension <paramref name="ldvt"/> by <paramref name="n"/>.
		/// <list>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="a"/>', <c>vt</c> contains the <paramref name="n"/> by <paramref name="n"/> orthogonal matrix V**T.</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="s"/>', <c>vt</c> contains the first min(m,n) rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="n"/>' or 'O', <c>vt</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldvt">The leading dimension of the array <paramref name="vt"/>. <c>ldvt &gt;= 1</c>. If <paramref name="jobvt"/> == '<paramref name="a"/>', 
		/// <c>ldvt &gt;= <paramref name="n"/></c>; if <paramref name="jobvt"/> == '<paramref name="s"/>', <c><paramref name="ldvt"/> &gt;= min(<paramref name="m"/>,<paramref name="n"/>)</c>.</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.
		/// The length of <c>work</c> should be at least 2*min(<paramref name="m"/>,<paramref name="n"/>)+max(<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="rwork">Dimension 5*min(<paramref name="m"/>,<paramref name="n"/>).
		/// On exit, if method returns a value greater than 0, <c>rwork[0:min(<paramref name="m"/>,<paramref name="n"/>)-2]</c> contains the unconverged superdiagonal elements of an upper bidiagonal
		/// matrix B whose diagonal is in <paramref name="s"/> (not necessarily sorted).
		/// B satisfies <paramref name="a"/> = <paramref name="u"/> * B * <paramref name="vt"/>, so it has the same singular
		/// values as <paramref name="a"/>, and singular vectors related by <paramref name="u"/> and <paramref name="vt"/>.</param>
		/// <returns><list>
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: if CBDSQR did not converge, specifies how many
		/// superdiagonals of an intermediate bidiagonal form B
		/// did not converge to zero.See the description of <paramref name="rwork"/>
		/// above for details.</item>
		/// </list></returns>
		int Cgesvd(char jobu, char jobvt, int m, int n, ComplexFloat[] a, int lda, float[] s, ComplexFloat[] u, int ldu, ComplexFloat[] vt, int ldvt, ComplexFloat[] work, float[] rwork);

		/// <summary>
		/// Computes the singular value decomposition (SVD) of a complex
		/// M by N matrix A, optionally computing the left and/or right singular
		/// vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V)
		/// where SIGMA is an M by N matrix which is zero except for its
		/// min(m,n) diagonal elements, U is an M by M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA
		/// are the singular values of A. They are real and non-negative, and
		/// are returned in descending order. The first min(m,n) columns of
		/// U and V are the left and right singular vectors of A.
		/// Note that the routine returns V**H, not V.
		/// </summary>
		/// <param name="jobu">
		/// Specifies options for computing all or part of the matrix <paramref name="u"/>:
		/// <list>
		/// <item> = '<paramref name="a"/>': all <paramref name="m"/> columns of <paramref name="u"/> are returned in array <paramref name="u"/>.</item>
		/// <item> = '<paramref name="s"/>': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are returned in the array <paramref name="u"/>.</item>
		/// <item> = 'O': the first min(m,n) columns of <paramref name="u"/> (the left singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item> = '<paramref name="n"/>': no columns of <paramref name="u"/> (no left singular vectors) are computed. </item>
		/// </list>
		/// </param>
		/// <param name="jobvt">
		/// Specifies options for computing all or part of the matrix V**T:
		/// <list>
		/// <item>'<paramref name="a"/>': all <paramref name="n"/> rows of V**T are returned in the array <paramref name="vt"/>.</item>
		/// <item>'<paramref name="s"/>': the first min(m,n) rows of V**T (the right singular vectors) are returned in the array <paramref name="vt"/>.</item>
		/// <item>'O': the first min(m,n) rows of V**T (the right singular vectors) are overwritten on the array <paramref name="a"/>.</item>
		/// <item>'<paramref name="n"/>': no rows of V**T (no right singular vectors) are computed.</item>
		/// </list>
		/// </param>
		/// <param name="m">The number of rows of the input matrix <paramref name="a"/>. <paramref name="m"/> &gt;= 0.</param>
		/// <param name="n">The number of columns of the input matrix <paramref name="a"/>. <paramref name="n"/> &gt;= 0.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. On entry, the <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.
		/// On exit:<list>
		/// <item>if <paramref name="jobu"/> == 'O', <c>a</c> is overwritten with the first min(m,n) columns of <paramref name="u"/> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobvt"/> == 'O', <c>a</c> is overwritten with the first min(m,n)rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>if <paramref name="jobu"/> != 'O' and <paramref name="jobvt"/> != 'O', the contents of <c>a</c> are destroyed.</item>
		/// </list></param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="s">Dimension min(<paramref name="m"/>,<paramref name="n"/>). The singular values of <paramref name="a"/>, sorted so that <c>s[i] &gt;= s[i+1]</c>.</param>
		/// <param name="u">Dimension <paramref name="ldu"/> by UCOL, <paramref name="ldu"/> by <paramref name="m"/> if <paramref name="jobu"/> = '<paramref name="a"/>', or <paramref name="ldu"/> by min(<paramref name="m"/>,<paramref name="n"/>) if <paramref name="jobu"/> = '<paramref name="s"/>'.
		/// <list>
		/// <item>If <paramref name="jobu"/> == '<paramref name="a"/>', <c>u</c> contains the <paramref name="m"/> by <paramref name="m"/> orthogonal matrix <c>u</c>.</item>
		/// <item>If <paramref name="jobu"/> == '<paramref name="s"/>', <c>u</c> contains the first min(m,n) columns of <c>u</c> (the left singular vectors, stored columnwise).</item>
		/// <item>if <paramref name="jobu"/> == '<paramref name="n"/>' or 'O', <c>u</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldu">The leading dimension of the array <paramref name="u"/>. <c>ldu &gt;= 1</c>. If <paramref name="jobu"/> = '<paramref name="s"/>' or '<paramref name="a"/>', <c>ldu &gt;= <paramref name="m"/></c>.</param>
		/// <param name="vt">Dimension <paramref name="ldvt"/> by <paramref name="n"/>.
		/// <list>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="a"/>', <c>vt</c> contains the <paramref name="n"/> by <paramref name="n"/> orthogonal matrix V**T.</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="s"/>', <c>vt</c> contains the first min(m,n) rows of V**T (the right singular vectors, stored rowwise).</item>
		/// <item>If <paramref name="jobvt"/> == '<paramref name="n"/>' or 'O', <c>vt</c> is not referenced.</item>
		/// </list></param>
		/// <param name="ldvt">The leading dimension of the array <paramref name="vt"/>. <c>ldvt &gt;= 1</c>. If <paramref name="jobvt"/> == '<paramref name="a"/>', 
		/// <c>ldvt &gt;= <paramref name="n"/></c>; if <paramref name="jobvt"/> == '<paramref name="s"/>', <c><paramref name="ldvt"/> &gt;= min(<paramref name="m"/>,<paramref name="n"/>)</c>.</param>
		/// <param name="work">Work array. On exit, <paramref name="work"/>[0] returns the optimal length of <paramref name="work"/> to use.
		/// The length of <c>work</c> should be at least 2*min(<paramref name="m"/>,<paramref name="n"/>)+max(<paramref name="m"/>,<paramref name="n"/>).</param>
		/// <param name="rwork">Dimension 5*min(<paramref name="m"/>,<paramref name="n"/>).
		/// On exit, if method returns a value greater than 0, <c>rwork[0:min(<paramref name="m"/>,<paramref name="n"/>)-2]</c> contains the unconverged superdiagonal elements of an upper bidiagonal
		/// matrix B whose diagonal is in <paramref name="s"/> (not necessarily sorted).
		/// B satisfies <paramref name="a"/> = <paramref name="u"/> * B * <paramref name="vt"/>, so it has the same singular
		/// values as <paramref name="a"/>, and singular vectors related by <paramref name="u"/> and <paramref name="vt"/>.</param>
		/// <returns><list>
		/// <item>0: successful exit.</item>
		/// <item>&lt; 0: the i-th argument had an illegal value.</item>
		/// <item>&gt; 0: if ZBDSQR did not converge, specifies how many
		/// superdiagonals of an intermediate bidiagonal form B
		/// did not converge to zero.See the description of <paramref name="rwork"/>
		/// above for details.</item>
		/// </list></returns>
		/// <remarks><paramref name="jobvt"/> and <paramref name="jobu"/> cannot both be 'O'.</remarks>
		int Zgesvd(char jobu, char jobvt, int m, int n, ComplexDouble[] a, int lda, double[] s, ComplexDouble[] u, int ldu, ComplexDouble[] vt, int ldvt, ComplexDouble[] work, double[] rwork);

		/// <summary>
		/// Returns the value of the one norm, or the Frobenius norm, or
		/// the infinity norm, or the element of largest absolute value of a
		/// matrix A.
		/// </summary>
		/// <param name="norm">Specifies the value to be returned.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m &gt;= 0</c>. When <c>m == 0</c>,
		/// 0 is returned.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>. When <c>n == 0</c>,
		/// 0 is returned.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. The <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <returns><list>
		/// <item>max(abs(<paramref name="a"/>[i,j])), if <paramref name="norm"/> == 'M' or 'm'.</item>
		/// <item>one norm of a matrix (maximum column sum), if <paramref name="norm"/> == '1', 'O' or 'o'.</item>
		/// <item>infinity norm of a matrix (maximum row sum), if <paramref name="norm"/> == 'I' or 'i'.</item>
		/// <item>Frobenius norm of a matrix (square root of sum of squares), if <paramref name="norm"/> == 'F', 'f', 'E' or 'e'.</item>
		/// </list>
		/// Note that max(abs(<paramref name="a"/>[i,j])) is not a matrix norm. 
		///</returns>
		float Slange(char norm, int m, int n, float[] a, int lda);

		/// <summary>
		/// Returns the value of the one norm, or the Frobenius norm, or
		/// the infinity norm, or the element of largest absolute value of a
		/// matrix A.
		/// </summary>
		/// <param name="norm">Specifies the value to be returned.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m &gt;= 0</c>. When <c>m == 0</c>,
		/// 0 is returned.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>. When <c>n == 0</c>,
		/// 0 is returned.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. The <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="work">Work array with a length of at least <paramref name="m"/> when <paramref name="norm"/> == 'I',
		/// otherwise, the array is not referenced.</param>
		/// <returns><list>
		/// <item>max(abs(<paramref name="a"/>[i,j])), if <paramref name="norm"/> == 'M' or 'm'.</item>
		/// <item>one norm of a matrix (maximum column sum), if <paramref name="norm"/> == '1', 'O' or 'o'.</item>
		/// <item>infinity norm of a matrix (maximum row sum), if <paramref name="norm"/> == 'I' or 'i'.</item>
		/// <item>Frobenius norm of a matrix (square root of sum of squares), if <paramref name="norm"/> == 'F', 'f', 'E' or 'e'.</item>
		/// </list>
		/// Note that max(abs(<paramref name="a"/>[i,j])) is not a matrix norm. 
		///</returns>
		float Slange(char norm, int m, int n, float[] a, int lda, float[] work);

		/// <summary>
		/// Returns the value of the one norm, or the Frobenius norm, or
		/// the infinity norm, or the element of largest absolute value of a
		/// matrix A.
		/// </summary>
		/// <param name="norm">Specifies the value to be returned.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m &gt;= 0</c>. When <c>m == 0</c>,
		/// 0 is returned.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>. When <c>n == 0</c>,
		/// 0 is returned.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. The <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <returns><list>
		/// <item>max(abs(<paramref name="a"/>[i,j])), if <paramref name="norm"/> == 'M' or 'm'.</item>
		/// <item>one norm of a matrix (maximum column sum), if <paramref name="norm"/> == '1', 'O' or 'o'.</item>
		/// <item>infinity norm of a matrix (maximum row sum), if <paramref name="norm"/> == 'I' or 'i'.</item>
		/// <item>Frobenius norm of a matrix (square root of sum of squares), if <paramref name="norm"/> == 'F', 'f', 'E' or 'e'.</item>
		/// </list>
		/// Note that max(abs(<paramref name="a"/>[i,j])) is not a matrix norm. 
		///</returns>
		double Dlange(char norm, int m, int n, double[] a, int lda);

		/// <summary>
		/// Returns the value of the one norm, or the Frobenius norm, or
		/// the infinity norm, or the element of largest absolute value of a
		/// matrix A.
		/// </summary>
		/// <param name="norm">Specifies the value to be returned.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m &gt;= 0</c>. When <c>m == 0</c>,
		/// 0 is returned.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>. When <c>n == 0</c>,
		/// 0 is returned.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. The <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="work">Work array with a length of at least <paramref name="m"/> when <paramref name="norm"/> == 'I',
		/// otherwise, the array is not referenced.</param>
		/// <returns><list>
		/// <item>max(abs(<paramref name="a"/>[i,j])), if <paramref name="norm"/> == 'M' or 'm'.</item>
		/// <item>one norm of a matrix (maximum column sum), if <paramref name="norm"/> == '1', 'O' or 'o'.</item>
		/// <item>infinity norm of a matrix (maximum row sum), if <paramref name="norm"/> == 'I' or 'i'.</item>
		/// <item>Frobenius norm of a matrix (square root of sum of squares), if <paramref name="norm"/> == 'F', 'f', 'E' or 'e'.</item>
		/// </list>
		/// Note that max(abs(<paramref name="a"/>[i,j])) is not a matrix norm. 
		///</returns>
		double Dlange(char norm, int m, int n, double[] a, int lda, double[] work);

		/// <summary>
		/// Returns the value of the one norm, or the Frobenius norm, or
		/// the infinity norm, or the element of largest absolute value of a
		/// matrix A.
		/// </summary>
		/// <param name="norm">Specifies the value to be returned.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m &gt;= 0</c>. When <c>m == 0</c>,
		/// 0 is returned.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>. When <c>n == 0</c>,
		/// 0 is returned.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. The <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <returns><list>
		/// <item>max(abs(<paramref name="a"/>[i,j])), if <paramref name="norm"/> == 'M' or 'm'.</item>
		/// <item>one norm of a matrix (maximum column sum), if <paramref name="norm"/> == '1', 'O' or 'o'.</item>
		/// <item>infinity norm of a matrix (maximum row sum), if <paramref name="norm"/> == 'I' or 'i'.</item>
		/// <item>Frobenius norm of a matrix (square root of sum of squares), if <paramref name="norm"/> == 'F', 'f', 'E' or 'e'.</item>
		/// </list>
		/// Note that max(abs(<paramref name="a"/>[i,j])) is not a matrix norm. 
		///</returns>
		float Clange(char norm, int m, int n, ComplexFloat[] a, int lda);

		/// <summary>
		/// Returns the value of the one norm, or the Frobenius norm, or
		/// the infinity norm, or the element of largest absolute value of a
		/// matrix A.
		/// </summary>
		/// <param name="norm">Specifies the value to be returned.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m &gt;= 0</c>. When <c>m == 0</c>,
		/// 0 is returned.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>. When <c>n == 0</c>,
		/// 0 is returned.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. The <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="work">Work array with a length of at least <paramref name="m"/> when <paramref name="norm"/> == 'I',
		/// otherwise, the array is not referenced.</param>
		/// <returns><list>
		/// <item>max(abs(<paramref name="a"/>[i,j])), if <paramref name="norm"/> == 'M' or 'm'.</item>
		/// <item>one norm of a matrix (maximum column sum), if <paramref name="norm"/> == '1', 'O' or 'o'.</item>
		/// <item>infinity norm of a matrix (maximum row sum), if <paramref name="norm"/> == 'I' or 'i'.</item>
		/// <item>Frobenius norm of a matrix (square root of sum of squares), if <paramref name="norm"/> == 'F', 'f', 'E' or 'e'.</item>
		/// </list>
		/// Note that max(abs(<paramref name="a"/>[i,j])) is not a matrix norm. 
		///</returns>
		float Clange(char norm, int m, int n, ComplexFloat[] a, int lda, float[] work);

		/// <summary>
		/// Returns the value of the one norm, or the Frobenius norm, or
		/// the infinity norm, or the element of largest absolute value of a
		/// matrix A.
		/// </summary>
		/// <param name="norm">Specifies the value to be returned.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m &gt;= 0</c>. When <c>m == 0</c>,
		/// 0 is returned.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>. When <c>n == 0</c>,
		/// 0 is returned.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. The <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <returns><list>
		/// <item>max(abs(<paramref name="a"/>[i,j])), if <paramref name="norm"/> == 'M' or 'm'.</item>
		/// <item>one norm of a matrix (maximum column sum), if <paramref name="norm"/> == '1', 'O' or 'o'.</item>
		/// <item>infinity norm of a matrix (maximum row sum), if <paramref name="norm"/> == 'I' or 'i'.</item>
		/// <item>Frobenius norm of a matrix (square root of sum of squares), if <paramref name="norm"/> == 'F', 'f', 'E' or 'e'.</item>
		/// </list>
		/// Note that max(abs(<paramref name="a"/>[i,j])) is not a matrix norm. 
		///</returns>
		double Zlange(char norm, int m, int n, ComplexDouble[] a, int lda);

		/// <summary>
		/// Returns the value of the one norm, or the Frobenius norm, or
		/// the infinity norm, or the element of largest absolute value of a
		/// matrix A.
		/// </summary>
		/// <param name="norm">Specifies the value to be returned.</param>
		/// <param name="m">The number of rows of the matrix <paramref name="a"/>. <c>m &gt;= 0</c>. When <c>m == 0</c>,
		/// 0 is returned.</param>
		/// <param name="n">The number of columns of the matrix <paramref name="a"/>. <c>n &gt;= 0</c>. When <c>n == 0</c>,
		/// 0 is returned.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>. The <paramref name="m"/> by <paramref name="n"/> matrix <c>a</c>.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>. <c>lda &gt;= max(1,<paramref name="m"/>)</c>.</param>
		/// <param name="work">Work array with a length of at least <paramref name="m"/> when <paramref name="norm"/> == 'I',
		/// otherwise, the array is not referenced.</param>
		/// <returns><list>
		/// <item>max(abs(<paramref name="a"/>[i,j])), if <paramref name="norm"/> == 'M' or 'm'.</item>
		/// <item>one norm of a matrix (maximum column sum), if <paramref name="norm"/> == '1', 'O' or 'o'.</item>
		/// <item>infinity norm of a matrix (maximum row sum), if <paramref name="norm"/> == 'I' or 'i'.</item>
		/// <item>Frobenius norm of a matrix (square root of sum of squares), if <paramref name="norm"/> == 'F', 'f', 'E' or 'e'.</item>
		/// </list>
		/// Note that max(abs(<paramref name="a"/>[i,j])) is not a matrix norm. 
		///</returns>
		double Zlange(char norm, int m, int n, ComplexDouble[] a, int lda, double[] work);

		/// <summary>
		///  Estimates the reciprocal of the condition number of a general
		///  real matrix A, in either the 1-norm or the infinity-norm, using
		///  the LU factorization computed by SGETRF.
		///  An estimate is obtained for norm(inv(A)), and the reciprocal of the
		///  condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
		/// </summary>
		/// <param name="norm">Specifies whether the 1-norm condition number or the infinity-norm condition number is required:
		/// <list>
		/// <item>'1' or 'O':  1-norm;</item>
		/// <item>'I': Infinity-norm.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>.  <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by SGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>.  <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="anorm"><list>
		/// <item>If <paramref name="norm"/> == '1' or 'O', the 1-norm of the original matrix A.</item>
		/// <item>If <paramref name="norm"/> == 'I', the infinity-norm of the original matrix A.</item>
		/// </list></param>
		/// <param name="rcond">The reciprocal of the condition number of the matrix <paramref name="a"/>,
		/// computed as 1/(norm(<paramref name="a"/>) * norm(inv(<paramref name="a"/>))).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sgecon(char norm, int n, float[] a, int lda, float anorm, ref float rcond);

		/// <summary>
		///  Estimates the reciprocal of the condition number of a general
		///  real matrix A, in either the 1-norm or the infinity-norm, using
		///  the LU factorization computed by SGETRF.
		///  An estimate is obtained for norm(inv(A)), and the reciprocal of the
		///  condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
		/// </summary>
		/// <param name="norm">Specifies whether the 1-norm condition number or the infinity-norm condition number is required:
		/// <list>
		/// <item>'1' or 'O':  1-norm;</item>
		/// <item>'I': Infinity-norm.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>.  <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by SGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>.  <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="anorm"><list>
		/// <item>If <paramref name="norm"/> == '1' or 'O', the 1-norm of the original matrix A.</item>
		/// <item>If <paramref name="norm"/> == 'I', the infinity-norm of the original matrix A.</item>
		/// </list></param>
		/// <param name="rcond">The reciprocal of the condition number of the matrix <paramref name="a"/>,
		/// computed as 1/(norm(<paramref name="a"/>) * norm(inv(<paramref name="a"/>))).</param>
		/// <param name="work">Dimension 4*<paramref name="n"/>.</param>
		/// <param name="iwork">Dimension <paramref name="n"/>.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Sgecon(char norm, int n, float[] a, int lda, float anorm, ref float rcond, float[] work, int[] iwork);

		/// <summary>
		///  Estimates the reciprocal of the condition number of a general
		///  real matrix A, in either the 1-norm or the infinity-norm, using
		///  the LU factorization computed by DGETRF.
		///  An estimate is obtained for norm(inv(A)), and the reciprocal of the
		///  condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
		/// </summary>
		/// <param name="norm">Specifies whether the 1-norm condition number or the infinity-norm condition number is required:
		/// <list>
		/// <item>'1' or 'O':  1-norm;</item>
		/// <item>'I': Infinity-norm.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>.  <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by DGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>.  <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="anorm"><list>
		/// <item>If <paramref name="norm"/> == '1' or 'O', the 1-norm of the original matrix A.</item>
		/// <item>If <paramref name="norm"/> == 'I', the infinity-norm of the original matrix A.</item>
		/// </list></param>
		/// <param name="rcond">The reciprocal of the condition number of the matrix <paramref name="a"/>,
		/// computed as 1/(norm(<paramref name="a"/>) * norm(inv(<paramref name="a"/>))).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dgecon(char norm, int n, double[] a, int lda, double anorm, ref double rcond);

		/// <summary>
		///  Estimates the reciprocal of the condition number of a general
		///  real matrix A, in either the 1-norm or the infinity-norm, using
		///  the LU factorization computed by DGETRF.
		///  An estimate is obtained for norm(inv(A)), and the reciprocal of the
		///  condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
		/// </summary>
		/// <param name="norm">Specifies whether the 1-norm condition number or the infinity-norm condition number is required:
		/// <list>
		/// <item>'1' or 'O':  1-norm;</item>
		/// <item>'I': Infinity-norm.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>.  <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by DGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>.  <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="anorm"><list>
		/// <item>If <paramref name="norm"/> == '1' or 'O', the 1-norm of the original matrix A.</item>
		/// <item>If <paramref name="norm"/> == 'I', the infinity-norm of the original matrix A.</item>
		/// </list></param>
		/// <param name="rcond">The reciprocal of the condition number of the matrix <paramref name="a"/>,
		/// computed as 1/(norm(<paramref name="a"/>) * norm(inv(<paramref name="a"/>))).</param>
		/// <param name="work">Dimension 4*<paramref name="n"/>.</param>
		/// <param name="iwork">Dimension <paramref name="n"/>.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Dgecon(char norm, int n, double[] a, int lda, double anorm, ref double rcond, double[] work, int[] iwork);

		/// <summary>
		///  Estimates the reciprocal of the condition number of a general
		///  real matrix A, in either the 1-norm or the infinity-norm, using
		///  the LU factorization computed by CGETRF.
		///  An estimate is obtained for norm(inv(A)), and the reciprocal of the
		///  condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
		/// </summary>
		/// <param name="norm">Specifies whether the 1-norm condition number or the infinity-norm condition number is required:
		/// <list>
		/// <item>'1' or 'O':  1-norm;</item>
		/// <item>'I': Infinity-norm.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>.  <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by CGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>.  <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="anorm"><list>
		/// <item>If <paramref name="norm"/> == '1' or 'O', the 1-norm of the original matrix A.</item>
		/// <item>If <paramref name="norm"/> == 'I', the infinity-norm of the original matrix A.</item>
		/// </list></param>
		/// <param name="rcond">The reciprocal of the condition number of the matrix <paramref name="a"/>,
		/// computed as 1/(norm(<paramref name="a"/>) * norm(inv(<paramref name="a"/>))).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cgecon(char norm, int n, ComplexFloat[] a, int lda, float anorm, ref float rcond);

		/// <summary>
		///  Estimates the reciprocal of the condition number of a general
		///  real matrix A, in either the 1-norm or the infinity-norm, using
		///  the LU factorization computed by CGETRF.
		///  An estimate is obtained for norm(inv(A)), and the reciprocal of the
		///  condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
		/// </summary>
		/// <param name="norm">Specifies whether the 1-norm condition number or the infinity-norm condition number is required:
		/// <list>
		/// <item>'1' or 'O':  1-norm;</item>
		/// <item>'I': Infinity-norm.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>.  <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by CGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>.  <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="anorm"><list>
		/// <item>If <paramref name="norm"/> == '1' or 'O', the 1-norm of the original matrix A.</item>
		/// <item>If <paramref name="norm"/> == 'I', the infinity-norm of the original matrix A.</item>
		/// </list></param>
		/// <param name="rcond">The reciprocal of the condition number of the matrix <paramref name="a"/>,
		/// computed as 1/(norm(<paramref name="a"/>) * norm(inv(<paramref name="a"/>))).</param>
		/// <param name="work">Dimension 2*<paramref name="n"/>.</param>
		/// <param name="rwork">Dimension 2*<paramref name="n"/>.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Cgecon(char norm, int n, ComplexFloat[] a, int lda, float anorm, ref float rcond, ComplexFloat[] work, float[] rwork);

		/// <summary>
		///  Estimates the reciprocal of the condition number of a general
		///  real matrix A, in either the 1-norm or the infinity-norm, using
		///  the LU factorization computed by ZGETRF.
		///  An estimate is obtained for norm(inv(A)), and the reciprocal of the
		///  condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
		/// </summary>
		/// <param name="norm">Specifies whether the 1-norm condition number or the infinity-norm condition number is required:
		/// <list>
		/// <item>'1' or 'O':  1-norm;</item>
		/// <item>'I': Infinity-norm.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>.  <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by ZGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>.  <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="anorm"><list>
		/// <item>If <paramref name="norm"/> == '1' or 'O', the 1-norm of the original matrix A.</item>
		/// <item>If <paramref name="norm"/> == 'I', the infinity-norm of the original matrix A.</item>
		/// </list></param>
		/// <param name="rcond">The reciprocal of the condition number of the matrix <paramref name="a"/>,
		/// computed as 1/(norm(<paramref name="a"/>) * norm(inv(<paramref name="a"/>))).</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zgecon(char norm, int n, ComplexDouble[] a, int lda, double anorm, ref double rcond);

		/// <summary>
		///  Estimates the reciprocal of the condition number of a general
		///  real matrix A, in either the 1-norm or the infinity-norm, using
		///  the LU factorization computed by ZGETRF.
		///  An estimate is obtained for norm(inv(A)), and the reciprocal of the
		///  condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
		/// </summary>
		/// <param name="norm">Specifies whether the 1-norm condition number or the infinity-norm condition number is required:
		/// <list>
		/// <item>'1' or 'O':  1-norm;</item>
		/// <item>'I': Infinity-norm.</item>
		/// </list></param>
		/// <param name="n">The order of the matrix <paramref name="a"/>.  <c>n &gt;= 0</c>.</param>
		/// <param name="a">Dimension <paramref name="lda"/> by <paramref name="n"/>.
		/// The factors L and U from the factorization A = P*L*U as computed by ZGETRF.</param>
		/// <param name="lda">The leading dimension of the array <paramref name="a"/>.  <c>lda</c> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="anorm"><list>
		/// <item>If <paramref name="norm"/> == '1' or 'O', the 1-norm of the original matrix A.</item>
		/// <item>If <paramref name="norm"/> == 'I', the infinity-norm of the original matrix A.</item>
		/// </list></param>
		/// <param name="rcond">The reciprocal of the condition number of the matrix <paramref name="a"/>,
		/// computed as 1/(norm(<paramref name="a"/>) * norm(inv(<paramref name="a"/>))).</param>
		/// <param name="work">Dimension 2*<paramref name="n"/>.</param>
		/// <param name="rwork">Dimension 2*<paramref name="n"/>.</param>
		/// <returns>0 on successful exit, or -i, the i-th argument had an illegal value.</returns>
		int Zgecon(char norm, int n, ComplexDouble[] a, int lda, double anorm, ref double rcond, ComplexDouble[] work, double[] rwork);


		/// <summary>
		/// ILAENV is called from the LAPACK routines to choose problem-dependent
		/// parameters for the local environment. 
		/// </summary>
		/// <param name="ispec">
		/// Specifies the parameter to be returned as the value of ILAENV.
		/// <list>
		/// <item>1: the optimal blocksize; if this value is 1, an unblocked
		/// algorithm will give the best performance.</item>
		/// <item>2: the minimum block size for which the block routine
		/// should be used; if the usable block size is less than
		/// this value, an unblocked routine should be used.</item>
		/// <item>3: the crossover point (in a block routine, for N less
		/// than this value, an unblocked routine should be used).</item>
		/// <item>4: the number of shifts, used in the nonsymmetric
		/// eigenvalue routines.</item>
		/// <item>5: the minimum column dimension for blocking to be used;
		/// rectangular blocks must have dimension at least k by m,
		/// where k is given by ILAENV(2,...) and m by ILAENV(5,...).</item>
		/// <item>6: the crossover point for the SVD (when reducing an m by n
		/// matrix to bidiagonal form, if max(m,n)/min(m,n) exceeds
		/// this value, a QR factorization is used first to reduce
		/// the matrix to a triangular form.</item>
		/// <item>7: the number of processors.</item>
		/// <item>8: the crossover point for the multishift QR and QZ methods
		/// for nonsymmetric eigenvalue problems.</item>
		/// <item>9: maximum size of the subproblems at the bottom of the
		/// computation tree in the divide-and-conquer algorithm
		/// (used by xGELSD and xGESDD).</item>
		/// <item>10: ieee NaN arithmetic can be trusted not to trap.</item>
		/// <item>11: infinity arithmetic can be trusted not to trap.</item>
		/// </list></param>
		/// <param name="name">The name of the calling subroutine, in either upper case or
		/// lower case.</param>
		/// <param name="opts">The character options to the subroutine NAME, concatenated
		/// into a single character string.  For example, uplo == 'U', trans == 'T', and diag == 'N'
		/// for a triangular routine would be specified as opts = 'UTN'.</param>
		/// <param name="n1">Problem dimension for the subroutine <paramref name="name"/>. May not  be required.</param>
		/// <param name="n2">Problem dimension for the subroutine <paramref name="name"/>. May not  be required.</param>
		/// <param name="n3">Problem dimension for the subroutine <paramref name="name"/>. May not  be required.</param>
		/// <param name="n4">Problem dimension for the subroutine <paramref name="name"/>. May not  be required.</param>
		/// <returns>&gt;>=0: the value of the parameter specified by <paramref name="ispec"/>. &lt; 0:  the k-th argument had an illegal value.</returns>
		int Ilaenv(int ispec, string name, string opts, int n1, int n2, int n3, int n4);

		//int Sggev(char jobvl, char jobvr, int n, float[] a, int lda, float[] b, int ldb, float[] alphar, float[] alphai, float[] beta, float[] vl, int ldvl, float[] vr, int ldvr);
		//int Sggev(char jobvl, char jobvr, int n, float[] a, int lda, float[] b, int ldb, float[] alphar, float[] alphai, float[] beta, float[] vl, int ldvl, float[] vr, int ldvr, float[] work);
		//int Sggev(char jobvl, char jobvr, int n, float[] a, int lda, float[] b, int ldb, ref float[] alphar, ref float[] alphai, ref float[] beta, float[] vl, int ldvl, float[] vr, int ldvr, float[] work);
		//int Dggev(char jobvl, char jobvr, int n, double[] a, int lda, double[] b, int ldb, ref double[] alphar, ref double[] alphai, ref double[] beta, double[] vl, int ldvl, double[] vr, int ldvr, double[] work);
		//int Cggev(char jobvl, char jobvr, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ref ComplexFloat[] alpha, ref ComplexFloat[] beta, ComplexFloat[] vl, int ldvl, ComplexFloat[] vr, int ldvr, ComplexFloat[] work, float[] rwork);
		//int Zggev(char jobvl, char jobvr, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ref ComplexDouble[] alpha, ref ComplexDouble[] beta, ComplexDouble[] vl, int[] ldvl, ComplexDouble[] vr, int ldvr, ComplexDouble[] work, double[] rwork);
		//int Sgbbrd(char vect, int m, int n, int[] ncc, int kl, int ku, float[] ab, int ldab, float[] d, float[] e, float[] q, int ldq, float[] pt, int ldpt, float[] c, int[] ldc, float[] work);
		//int Sgebrd(int m, int n, float[] a, int lda, float[] d, float[] e, float[] tauq, float[] taup, float[] work);
		//int Dgbbrd(char vect, int m, int n, int[] ncc, int kl, int ku, double[] ab, int ldab, double[] d, double[] e, double[] q, int ldq, double[] pt, int ldpt, double[] c, int ldc, double[] work);
		//int Dgebrd(int m, int n, double[] a, int lda, double[] d, double[] e, double[] tauq, double[] taup, double[] work);
		//int Cgbbrd(char vect, int m, int n, int[] ncc, int kl, int ku, ComplexFloat[] ab, int ldab, float[] d, float[] e, ComplexFloat[] q, int ldq, ComplexFloat[] pt, int ldpt, ComplexFloat[] c, int ldc, ComplexFloat[] work, float[] rwork);
		//int Cgebrd(int m, int n, ComplexFloat[] a, int lda, float[] d, float[] e, ComplexFloat[] tauq, ComplexFloat[] taup, ComplexFloat[] work);
		//int Zgbbrd(char vect, int m, int n, int[] ncc, int kl, int ku, ComplexDouble[] ab, int ldab, double[] d, double[] e, ComplexDouble[] q, int ldq, ComplexDouble[] pt, int ldpt, ComplexDouble[] c, int ldc, ComplexDouble[] work, double[] rwork);
		//int Zgebrd(int m, int n, ComplexDouble[] a, int lda, double[] d, double[] e, ComplexDouble[] tauq, ComplexDouble[] taup, ComplexDouble[] work, int[] info);
		//int Sbdsdc(char uplo, char compq, int n, float[] d, float[] e, float[] u, int ldu, float[] vt, int ldvt, float[] q, int[] iq, float[] work, int iwork);
		//int Sbdsqr(char uplo, int n, int[] ncvt, int[] nru, int[] ncc, float[] d, float[] e, float[] vt, int ldvt, float[] u, int ldu, float[] c, int ldc, float[] work);
		//int Dbdsdc(char uplo, char compq, int n, double[] d, double[] e, double[] u, int ldu, double[] vt, int ldvt, double[] q, int[] iq, double[] work, int iwork);
		//int Dbdsqr(char uplo, int n, int[] ncvt, int[] nru, int[] ncc, double[] d, double[] e, double[] vt, int ldvt, double[] u, int ldu, double[] c, int ldc, double[] work);
		//int Cbdsqr(char uplo, int n, int[] ncvt, int[] nru, int[] ncc, float[] d, float[] e, ComplexFloat[] vt, int ldvt, ComplexFloat[] u, int ldu, ComplexFloat[] c, int ldc, float[] rwork);
		//int Zbdsqr(char uplo, int n, int[] ncvt, int[] nru, int[] ncc, double[] d, double[] e, ComplexDouble[] vt, int ldvt, ComplexDouble[] u, int ldu, ComplexDouble[] c, int ldc, double[] rwork);

		//int Sdisna(char job, int m, int n, float[] d, float[] sep);
		//int Sgbcon(char norm, int n, int kl, int ku, float[] ab, int ldab, int[] ipiv, float[] anorm, float[] rcond, float[] work, int iwork);
		//int Sgbequ(int m, int n, int kl, int ku, float[] ab, int ldab, float[] r, float[] c, float[] rowcnd, float[] colcnd, float[] amax);
		//int Sgbrfs(char trans, int n, int kl, int ku, int nrhs, float[] ab, int ldab, float[] afb, int ldafb, int[] ipiv, float[] b, int ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work, int iwork);
		//int Sgbsv(int n, int kl, int ku, int nrhs, float[] ab, int ldab, int[] ipiv, float[] b, int ldb);
		//int Sgbsvx(char fact, char trans, int n, int kl, int ku, int nrhs, float[] ab, int ldab, float[] afb, int ldafb, int[] ipiv, char equed, float[] r, float[] c, float[] b, int ldb, float[] x, int ldx, float[] rcond, float[] ferr, float[] berr, float[] work, int iwork);
		//int Sgbtf2(int m, int n, int kl, int ku, float[] ab, int ldab, int[] ipiv);
		//int Sgbtrs(char trans, int n, int kl, int ku, int nrhs, float[] ab, int ldab, int[] ipiv, float[] b, int ldb);
		//int Sgebak(char job, char side, int n, int[] ilo, int[] ihi, float[] scale, int m, float[] v, int ldv);
		//int Sgebal(char job, int n, float[] a, int lda, int[] ilo, int[] ihi, float[] scale);
		//int Sgebd2(int m, int n, float[] a, int lda, float[] d, float[] e, float[] tauq, float[] taup, float[] work);
		//int Sgeequ(int m, int n, float[] a, int lda, float[] r, float[] c, float[] rowcnd, float[] colcnd, float[] amax);
		//int Sgees(char jobvs, char sort, L_fp select, int n, float[] a, int lda, int[] sdim, float[] wr, float[] wi, float[] vs, int ldvs, float[] work, bool[] bwork, int[] info);
		//int Sgeesx(char jobvs, char sort, L_fp select, char sense, int n, float[] a, int lda, int[] sdim, float[] wr, float[] wi, float[] vs, int ldvs, float[] rconde, float[] rcondv, float[] work, int iwork, int[] liwork, bool[] bwork );
		//int Sgeev(char jobvl, char jobvr, int n, float[] a, int lda, float[] wr, float[] wi, float[] vl, int ldvl, float[] vr, int ldvr, float[] work);
		//int Sgeevx(char balanc, char jobvl, char jobvr, char sense, int n, float[] a, int lda, float[] wr, float[] wi, float[] vl, int ldvl, float[] vr, int ldvr, int[] ilo, int[] ihi, float[] scale, float[] abnrm, float[] rconde, float[] rcondv, float[] work, int iwork);
		//int Sgegs(char jobvsl, char jobvsr, int n, float[] a, int lda, float[] b, int ldb, float[] alphar, float[] alphai, float[] beta, float[] vsl, int ldvsl, float[] vsr, int ldvsr, float[] work);
		//int Sgegv(char jobvl, char jobvr, int n, float[] a, int lda, float[] b, int ldb, float[] alphar, float[] alphai, float[] beta, float[] vl, int ldvl, float[] vr, int ldvr, float[] work);
		//int Sgehd2(int n, int[] ilo, int[] ihi, float[] a, int lda, float[] tau, float[] work);
		//int Sgehrd(int n, int[] ilo, int[] ihi, float[] a, int lda, float[] tau, float[] work);
		//int Sgelq2(int m, int n, float[] a, int lda, float[] tau, float[] work);
		//int Sgelqf(int m, int n, float[] a, int lda, float[] tau, float[] work);
		//int Sgelsd(int m, int n, int nrhs, float[] a, int lda, float[] b, int ldb, float[] s, float[] rcond, int[] rank, float[] work, int iwork);
		//int Sgelsx(int m, int n, int nrhs, float[] a, int lda, float[] b, int ldb, int[] jpvt, float[] rcond, int[] rank);
		//int Sgelsx(int m, int n, int nrhs, float[] a, int lda, float[] b, int ldb, int[] jpvt, float[] rcond, int[] rank, float[] work);
		//int Sgeql2(int m, int n, float[] a, int lda, float[] tau, float[] work);
		//int Sgeqlf(int m, int n, float[] a, int lda, float[] tau, float[] work);
		//int Sgeqpf(int m, int n, float[] a, int lda, int[] jpvt, float[] tau, float[] work);
		//int Sgeqr2(int m, int n, float[] a, int lda, float[] tau, float[] work);
		//int Sgeqrf(int m, int n, float[] a, int lda, float[] tau, float[] work);
		//int Sgerfs(char trans, int n, int nrhs, float[] a, int lda, float[] af, int ldaf, int[] ipiv, float[] b, int ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work, int iwork);
		//int Sgerq2(int m, int n, float[] a, int lda, float[] tau, float[] work);
		//int Sgerqf(int m, int n, float[] a, int lda, float[] tau, float[] work);
		//int Sgesc2(int n, float[] a, int lda, float[] rightSide, int[] ipiv, int[] jpiv, float[] scale);
		//int Sgesdd(char jobz, int m, int n, float[] a, int lda, float[] s, float[] u, int ldu, float[] vt, int ldvt, float[] work, int iwork);
		//int Sgesv(int n, int nrhs, float[] a, int lda, int[] ipiv, float[] b, int ldb);
		//int Sgesvx(char fact, char trans, int n, int nrhs, float[] a, int lda, float[] af, int ldaf, int[] ipiv, char equed, float[] r, float[] c, float[] b, int ldb, float[] x, int ldx, float[] rcond, float[] ferr, float[] berr, float[] work, int iwork);
		//int Sgetc2(int n, float[] a, int lda, int[] ipiv, int[] jpiv);
		//int Sgetf2(int m, int n, float[] a, int lda, int[] ipiv);
		//int Sggbak(char job, char side, int n, int[] ilo, int[] ihi, float[] lscale, float[] rscale, int m, float[] v, int ldv);
		//int Sggbal(char job, int n, float[] a, int lda, float[] b, int ldb, int[] ilo, int[] ihi, float[] lscale, float[] rscale, float[] work);
		//int Sgges(char jobvsl, char jobvsr, char sort, L_fp selctg, int n, float[] a, int lda, float[] b, int ldb, int[] sdim, float[] alphar, float[] alphai, float[] beta, float[] vsl, int ldvsl, float[] vsr, int ldvsr, float[] work, bool[] bwork);
		//int Sggesx(char jobvsl, char jobvsr, char sort, L_fp selctg, char sense, int n, float[] a, int lda, float[] b, int ldb, int[] sdim, float[] alphar, float[] alphai, float[] beta, float[] vsl, int ldvsl, float[] vsr, int ldvsr, float[] rconde, float[] rcondv, float[] work, int iwork, int[] liwork, bool[] bwork);
		//int Sggevx(char balanc, char jobvl, char jobvr, char sense, int n, float[] a, int lda, float[] b, int ldb, float[] alphar, float[] alphai, float[] beta, float[] vl, int ldvl, float[] vr, int ldvr, int[] ilo, int[] ihi, float[] lscale, float[] rscale, float[] abnrm, float[] bbnrm, float[] rconde, float[] rcondv, float[] work, int iwork, bool[] bwork);
		//int Sggglm(int n, int m, int[] p, float[] a, int lda, float[] b, int ldb, float[] d, float[] x, float[] y, float[] work);
		//int Sgghrd(char compq, char compz, int n, int[] ilo, int[] ihi, float[] a, int lda, float[] b, int ldb, float[] q, int ldq, float[] z, int ldz);
		//int Sgglse(int m, int n, int[] p, float[] a, int lda, float[] b, int ldb, float[] c, float[] d, float[] x, float[] work);
		//int Sggqrf(int n, int m, int[] p, float[] a, int lda, float[] taua, float[] b, int ldb, float[] taub, float[] work);
		//int Sggrqf(int m, int[] p, int n, float[] a, int lda, float[] taua, float[] b, int ldb, float[] taub, float[] work);
		//int Sggsvd(char jobu, char jobv, char jobq, int m, int n, int[] p, int k, int[] l, float[] a, int lda, float[] b, int ldb, float[] alpha, float[] beta, float[] u, int ldu, float[] v, int ldv, float[] q, int ldq, float[] work, int iwork);
		//int Sggsvp(char jobu, char jobv, char jobq, int m, int[] p, int n, float[] a, int lda, float[] b, int ldb, float[] tola, float[] tolb, int k, int[] l, float[] u, int ldu, float[] v, int ldv, float[] q, int ldq, int iwork, float[] tau, float[] work);
		//int Sgtcon(char norm, int n, float[] dl, float[] d, float[] du, float[] du2, int[] ipiv, float[] anorm, float[] rcond, float[] work, int iwork);
		//int Sgtrfs(char trans, int n, int nrhs, float[] dl, float[] d, float[] du, float[] dlf, float[] df, float[] duf, float[] du2, int[] ipiv, float[] b, int ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work, int iwork);
		//int Sgtsv(int n, int nrhs, float[] dl, float[] d, float[] du, float[] b, int ldb);
		//int Sgtsvx(char fact, char trans, int n, int nrhs, float[] dl, float[] d, float[] du, float[] dlf, float[] df, float[] duf, float[] du2, int[] ipiv, float[] b, int ldb, float[] x, int ldx, float[] rcond, float[] ferr, float[] berr, float[] work, int iwork);
		//int Sgbtrf(int m, int n, int kl, int ku, float[] ab, int ldab, int[] ipiv);
		//int Sgttrf(int n, float[] dl, float[] d, float[] du, float[] du2, int[] ipiv);
		//int Sgttrs(char trans, int n, int nrhs, float[] dl, float[] d, float[] du, float[] du2, int[] ipiv, float[] b, int ldb);
		//int Sgtts2(int[] itrans, int n, int nrhs, float[] dl, float[] d, float[] du, float[] du2, int[] ipiv, float[] b, int ldb);
		//int Shgeqz(char job, char compq, char compz, int n, int[] ilo, int[] ihi, float[] a, int lda, float[] b, int ldb, float[] alphar, float[] alphai, float[] beta, float[] q, int ldq, float[] z, int ldz, float[] work);
		//int Shsein(char side, char eigsrc, char initv, bool[] select, int n, float[] h, int ldh, float[] wr, float[] wi, float[] vl, int ldvl, float[] vr, int ldvr, int[] mm, int m, float[] work, int[] ifaill, int[] ifailr);
		//int Shseqr(char job, char compz, int n, int[] ilo, int[] ihi, float[] h, int ldh, float[] wr, float[] wi, float[] z, int ldz, float[] work);
		//int Slabad(float[] small, float[] large);
		//int Slabrd(int m, int n, int[] nb, float[] a, int lda, float[] d, float[] e, float[] tauq, float[] taup, float[] x, int ldx, float[] y, int ldy);
		//int Slacon(int n, float[] v, float[] x, int[] isgn, float[] est, int[] kase);
		//int Slacpy(char uplo, int m, int n, float[] a, int lda, float[] b, int ldb);
		//int Sladiv(float[] a, float[] b, float[] c, float[] d, float[] p, float[] q);
		//int Slae2(float[] a, float[] b, float[] c, float[] rt1, float[] rt2);
		//int Slaebz(int[] ijob, int[] nitmax, int n, int[] mmax, int[] minp, int[] nbmin, float[] abstol, float[] reltol, float[] pivmin, float[] d, float[] e, float[] e2, int[] nval, float[] ab, float[] c, int[] mout, int[] nab, float[] work, int iwork);
		//int Slaed0(int[] icompq, int[] qsiz, int n, float[] d, float[] e, float[] q, int ldq, float[] qstore, int ldqs, float[] work, int iwork);
		//int Slaed1(int n, float[] d, float[] q, int ldq, int[] indxq, float[] rho, int[] cutpnt, float[] work, int iwork);
		//int Slaed2(int k, int n, int[] n1, float[] d, float[] q, int ldq, int[] indxq, float[] rho, float[] z, float[] dlamda, float[] w, float[] q2, int[] indx, int[] indxc, int[] indxp, int[] coltyp);
		//int Slaed3(int k, int n, int[] n1, float[] d, float[] q, int ldq, float[] rho, float[] dlamda, float[] q2, int[] indx, int[] ctot, float[] w, float[] s);
		//int Slaed4(int n, int[] i, float[] d, float[] z, float[] delta, float[] rho, float[] dlam);
		//int Slaed5(int[] i, float[] d, float[] z, float[] delta, float[] rho, float[] dlam);
		//int Slaed6(int[] kniter, bool[] orgati, float[] rho, float[] d, float[] z, float[] finit, float[] tau);
		//int Slaed7(int[] icompq, int n, int[] qsiz, int[] tlvls, int[] curlvl, int[] curpbm, float[] d, float[] q, int ldq, int[] indxq, float[] rho, int[] cutpnt, float[] qstore, int[] qptr, int[] prmptr, int[] perm, int[] givptr, int[] givcol, float[] givnum, float[] work, int iwork);
		//int Slaed8(int[] icompq, int k, int n, int[] qsiz, float[] d, float[] q, int ldq, int[] indxq, float[] rho, int[] cutpnt, float[] z, float[] dlamda, float[] q2, int ldq2, float[] w, int[] perm, int[] givptr, int[] givcol, float[] givnum, int[] indxp, int[] indx);
		//int Slaed9(int k, int[] kstart, int[] kstop, int n, float[] d, float[] q, int ldq, float[] rho, float[] dlamda, float[] w, float[] s, int lds);
		//int Slaeda(int n, int[] tlvls, int[] curlvl, int[] curpbm, int[] prmptr, int[] perm, int[] givptr, int[] givcol, float[] givnum, float[] q, int[] qptr, float[] z, float[] ztemp);
		//int Slaein(bool[] rightv, bool[] noinit, int n, float[] h, int ldh, float[] wr, float[] wi, float[] vr, float[] vi, float[] b, int ldb, float[] work, float[] eps3, float[] smlnum, float[] bignum);
		//int Slaev2(float[] a, float[] b, float[] c, float[] rt1, float[] rt2, float[] cs1, float[] sn1);
		//int Slaexc(bool[] wantq, int n, float[] t, int ldt, float[] q, int ldq, int[] j1, int[] n1, int[] n2, float[] work);
		//int Slag2(float[] a, int lda, float[] b, int ldb, float[] safmin, float[] scale1, float[] scale2, float[] wr1, float[] wr2, float[] wi);
		//int Slags2(bool[] upper, float[] a1, float[] a2, float[] a3, float[] b1, float[] b2, float[] b3, float[] csu, float[] snu, float[] csv, float[] snv, float[] csq, float[] snq);
		//int Slagtf(int n, float[] a, float[] lambda, float[] b, float[] c, float[] tol, float[] d, int[] in);
		//int Slagtm(char trans, int n, int nrhs, float[] alpha, float[] dl, float[] d, float[] du, float[] x, int ldx, float[] beta, float[] b, int ldb);
		//int Slagts(int[] job, int n, float[] a, float[] b, float[] c, float[] d, int[] in, float[] y, float[] tol);
		//int Slagv2(float[] a, int lda, float[] b, int ldb, float[] alphar, float[] alphai, float[] beta, float[] csl, float[] snl, float[] csr, float[] snr);
		//int Slahqr(bool[] wantt, bool[] wantz, int n, int[] ilo, int[] ihi, float[] h, int ldh, float[] wr, float[] wi, int[] iloz, int[] ihiz, float[] z, int ldz, int[] info);
		//int Slahrd(int n, int k, int[] nb, float[] a, int lda, float[] tau, float[] t, int ldt, float[] y, int ldy);
		//int Slaic1(int[] job, int[] j, float[] x, float[] sest, float[] w, float[] gamma, float[] sestpr, float[] s, float[] c);
		//int Slaln2(bool[] ltrans, int[] na, int[] nw, float[] smin, float[] ca, float[] a, int lda, float[] d1, float[] d2, float[] b, int ldb, float[] wr, float[] wi, float[] x, int ldx, float[] scale, float[] xnorm);
		//int Slals0(int[] icompq, int[] nl, int[] nr, int[] sqre, int nrhs, float[] b, int ldb, float[] bx, int ldbx, int[] perm, int[] givptr, int[] givcol, int ldgcol, float[] givnum, int ldgnum, float[] poles, float[] difl, float[] difr, float[] z, int k, float[] c, float[] s, float[] work);
		//int Slalsa(int[] icompq, int[] smlsiz, int n, int nrhs, float[] b, int ldb, float[] bx, int ldbx, float[] u, int ldu, float[] vt, int k, float[] difl, float[] difr, float[] z, float[] poles, int[] givptr, int[] givcol, int ldgcol, int[] perm, float[] givnum, float[] c, float[] s, float[] work, int iwork);
		//int Slalsd(char uplo, int[] smlsiz, int n, int nrhs, float[] d, float[] e, float[] b, int ldb, float[] rcond, int[] rank, float[] work, int iwork);
		//int Slamc1(int[] beta, int[] t, bool[] rnd, bool[] ieee1);
		//int Slamc2(int[] beta, int[] t, bool[] rnd, float[] eps, int[] emin, float[] rmin, int[] emax, float[] rmax);
		//int Slamc4(int[] emin, float[] start, int[] base);
		//int Slamc5(int[] beta, int[] p, int[] emin, bool[] ieee, int[] emax, float[] rmax);
		//int Slamrg(int[] n1, int[] n2, float[] a, int[] strd1, int[] strd2, int[] index);
		//int Slanv2(float[] a, float[] b, float[] c, float[] d, float[] rt1r, float[] rt1i, float[] rt2r, float[] rt2i, float[] cs, float[] sn);
		//int Slapll(int n, float[] x, int[] incx, float[] y, int[] incy, float[] ssmin);
		//int Slapmt(bool[] forwrd, int m, int n, float[] x, int ldx, int k);
		//int Slaqgb(int m, int n, int kl, int ku, float[] ab, int ldab, float[] r, float[] c, float[] rowcnd, float[] colcnd, float[] amax, char equed);
		//int Slaqge(int m, int n, float[] a, int lda, float[] r, float[] c, float[] rowcnd, float[] colcnd, float[] amax, char equed);
		//int Slaqp2(int m, int n, int[] offset, float[] a, int lda, int[] jpvt, float[] tau, float[] vn1, float[] vn2, float[] work);
		//int Slaqps(int m, int n, int[] offset, int[] nb, int[] kb, float[] a, int lda, int[] jpvt, float[] tau, float[] vn1, float[] vn2, float[] auxv, float[] f, int ldf);
		//int Slaqsb(char uplo, int n, int[] kd, float[] ab, int ldab, float[] s, float[] scond, float[] amax, char equed);
		//int Slaqsp(char uplo, int n, float[] ap, float[] s, float[] scond, float[] amax, char equed);
		//int Slaqsy(char uplo, int n, float[] a, int lda, float[] s, float[] scond, float[] amax, char equed);
		//int Slaqtr(bool[] ltran, bool[] lreal, int n, float[] t, int ldt, float[] b, float[] w, float[] scale, float[] x, float[] work);
		//int Slar1v(int n, int[] b1, int[] bn, float[] sigma, float[] d, float[] l, float[] ld, float[] lld, float[] gersch, float[] z, float[] ztz, float[] mingma, int[] r, int[] isuppz, float[] work);
		//int Slar2v(int n, float[] x, float[] y, float[] z, int[] incx, float[] c, float[] s, int[] incc);
		//int Slarf(char side, int m, int n, float[] v, int[] incv, float[] tau, float[] c, int ldc, float[] work);
		//int Slarfb(char side, char trans, char direct, char storev, int m, int n, int k, float[] v, int ldv, float[] t, int ldt, float[] c, int ldc, float[] work, int ldwork);
		//int Slarfg(int n, float[] alpha, float[] x, int[] incx, float[] tau);
		//int Slarft(char direct, char storev, int n, int k, float[] v, int ldv, float[] tau, float[] t, int ldt);
		//int Slarfx(char side, int m, int n, float[] v, float[] tau, float[] c, int ldc, float[] work);
		//int Slargv(int n, float[] x, int[] incx, float[] y, int[] incy, float[] c, int[] incc);
		//int Slarnv(int[] idist, int[] iseed, int n, float[] x);
		//int Slarrb(int n, float[] d, float[] l, float[] ld, float[] lld, int[] ifirst, int[] ilast, float[] sigma, float[] reltol, float[] w, float[] wgap, float[] werr, float[] work, int iwork);
		//int Slarre(int n, float[] d, float[] e, float[] tol, int[] nsplit, int[] isplit, int m, float[] w, float[] woff, float[] gersch, float[] work);
		//int Slarrf(int n, float[] d, float[] l, float[] ld, float[] lld, int[] ifirst, int[] ilast, float[] w, float[] dplus, float[] lplus, float[] work, int iwork);
		//int Slarrv(int n, float[] d, float[] l, int[] isplit, int m, float[] w, int[] iblock, float[] gersch, float[] tol, float[] z, int ldz, int[] isuppz, float[] work, int iwork);
		//int Slartg(float[] f, float[] g, float[] cs, float[] sn, float[] r);
		//int Slartv(int n, float[] x, int[] incx, float[] y, int[] incy, float[] c, float[] s, int[] incc);
		//int Slaruv(int[] iseed, int n, float[] x);
		//int Slarz(char side, int m, int n, int[] l, float[] v, int[] incv, float[] tau, float[] c, int ldc, float[] work);
		//int Slarzb(char side, char trans, char direct, char storev, int m, int n, int k, int[] l, float[] v, int ldv, float[] t, int ldt, float[] c, int ldc, float[] work, int ldwork);
		//int Slarzt(char direct, char storev, int n, int k, float[] v, int ldv, float[] tau, float[] t, int ldt);
		//int Slas2(float[] f, float[] g, float[] h, float[] ssmin, float[] ssmax);
		//int Slascl(char type, int kl, int ku, float[] cfrom, float[] cto, int m, int n, float[] a, int lda);
		//int Slasd0(int n, int[] sqre, float[] d, float[] e, float[] u, int ldu, float[] vt, int ldvt, int[] smlsiz, int iwork, float[] work);
		//int Slasd1(int[] nl, int[] nr, int[] sqre, float[] d, float[] alpha, float[] beta, float[] u, int ldu, float[] vt, int ldvt, int[] idxq, int iwork, float[] work, int[] info);
		//int Slasd2(int[] nl, int[] nr, int[] sqre, int k, float[] d, float[] z, float[] alpha, float[] beta, float[] u, int ldu, float[] vt, int ldvt, float[] dsigma, float[] u2, int ldu2, float[] vt2, int ldvt2, int[] idxp, int[] idx, int[] idxc, int[] idxq, int[] coltyp);
		//int Slasd3(int[] nl, int[] nr, int[] sqre, int k, float[] d, float[] q, int ldq, float[] dsigma, float[] u, int ldu, float[] u2, int ldu2, float[] vt, int ldvt, float[] vt2, int ldvt2, int[] idxc, int[] ctot, float[] z, int[] info);
		//int Slasd4(int n, int[] i, float[] d, float[] z, float[] delta, float[] rho, float[] sigma, float[] work);
		//int Slasd5(int[] i, float[] d, float[] z, float[] delta, float[] rho, float[] dsigma, float[] work);
		//int Slasd6(int[] icompq, int[] nl, int[] nr, int[] sqre, float[] d, float[] vf, float[] vl, float[] alpha, float[] beta, int[] idxq, int[] perm, int[] givptr, int[] givcol, int ldgcol, float[] givnum, int ldgnum, float[] poles, float[] difl, float[] difr, float[] z, int k, float[] c, float[] s, float[] work, int iwork);
		//int Slasd7(int[] icompq, int[] nl, int[] nr, int[] sqre, int k, float[] d, float[] z, float[] zw, float[] vf, float[] vfw, float[] vl, float[] vlw, float[] alpha, float[] beta, float[] dsigma, int[] idx, int[] idxp, int[] idxq, int[] perm, int[] givptr, int[] givcol, int ldgcol, float[] givnum, int ldgnum, float[] c, float[] s);
		//int Slasd8(int[] icompq, int k, float[] d, float[] z, float[] vf, float[] vl, float[] difl, float[] difr, int lddifr, float[] dsigma, float[] work);
		//int Slasd9(int[] icompq, int ldu, int k, float[] d, float[] z, float[] vf, float[] vl, float[] difl, float[] difr, float[] dsigma, float[] work);
		//int Slasda(int[] icompq, int[] smlsiz, int n, int[] sqre, float[] d, float[] e, float[] u, int ldu, float[] vt, int k, float[] difl, float[] difr, float[] z, float[] poles, int[] givptr, int[] givcol, int ldgcol, int[] perm, float[] givnum, float[] c, float[] s, float[] work, int iwork);
		//int Slasdq(char uplo, int[] sqre, int n, int[] ncvt, int[] nru, int[] ncc, float[] d, float[] e, float[] vt, int ldvt, float[] u, int ldu, float[] c, int ldc, float[] work);
		//int Slasdt(int n, int[] lvl, int[] nd, int[] inode, int[] ndiml, int[] ndimr, int[] msub);
		//int Slaset(char uplo, int m, int n, float[] alpha, float[] beta, float[] a, int lda);
		//int Slasq1(int n, float[] d, float[] e, float[] work);
		//int Slasq2(int n, float[] z);
		//int Slasq3(int[] i0, int[] n0, float[] z, int[] pp, float[] dmin, float[] sigma, float[] desig, float[] qmax, int[] nfail, int[] iter, int[] ndiv, bool[] ieee);
		//int Slasq4(int[] i0, int[] n0, float[] z, int[] pp, int[] n0in, float[] dmin, float[] dmin1, float[] dmin2, float[] dn, float[] dn1, float[] dn2, float[] tau, int[] ttype);
		//int Slasq5(int[] i0, int[] n0, float[] z, int[] pp, float[] tau, float[] dmin, float[] dmin1, float[] dmin2, float[] dn, float[] dnm1, float[] dnm2, bool[] ieee);
		//int Slasq6(int[] i0, int[] n0, float[] z, int[] pp, float[] dmin, float[] dmin1, float[] dmin2, float[] dn, float[] dnm1, float[] dnm2);
		//int Slasr(char side, char pivot, char direct, int m, int n, float[] c, float[] s, float[] a, int lda);
		//int Slasrt(char id, int n, float[] d);
		//int Slassq(int n, float[] x, int[] incx, float[] scale, float[] sumsq);
		//int Slasv2(float[] f, float[] g, float[] h, float[] ssmin, float[] ssmax, float[] snr, float[] csr, float[] snl, float[] csl);
		//int Slaswp(int n, float[] a, int lda, int[] k1, int[] k2, int[] ipiv, int[] incx);
		//int Slasy2(bool[] ltranl, bool[] ltranr, int[] isgn, int[] n1, int[] n2, float[] tl, int ldtl, float[] tr, int ldtr, float[] b, int ldb, float[] scale, float[] x, int ldx, float[] xnorm);
		//int Slasyf(char uplo, int n, int[] nb, int[] kb, float[] a, int lda, int[] ipiv, float[] w, int ldw);
		//int Slatbs(char uplo, char trans, char diag, char normin, int n, int[] kd, float[] ab, int ldab, float[] x, float[] scale, float[] cnorm);
		//int Slatdf(int[] ijob, int n, float[] z, int ldz, float[] rightSide, float[] rdsum, float[] rdscal, int[] ipiv, int[] jpiv);
		//int Slatps(char uplo, char trans, char diag, char normin, int n, float[] ap, float[] x, float[] scale, float[] cnorm);
		//int Slatrd(char uplo, int n, int[] nb, float[] a, int lda, float[] e, float[] tau, float[] w, int ldw);
		//int Slatrs(char uplo, char trans, char diag, char normin, int n, float[] a, int lda, float[] x, float[] scale, float[] cnorm);
		//int Slatrz(int m, int n, int[] l, float[] a, int lda, float[] tau, float[] work);
		//int Slatzm(char side, int m, int n, float[] v, int[] incv, float[] tau, float[] c1, float[] c2, int ldc, float[] work);
		//int Slauu2(char uplo, int n, float[] a, int lda);
		//int Slauum(char uplo, int n, float[] a, int lda);
		//int Sopgtr(char uplo, int n, float[] ap, float[] tau, float[] q, int ldq, float[] work);
		//int Sopmtr(char side, char uplo, char trans, int m, int n, float[] ap, float[] tau, float[] c, int ldc, float[] work);
		//int Sorg2l(int m, int n, int k, float[] a, int lda, float[] tau, float[] work);
		//int Sorg2r(int m, int n, int k, float[] a, int lda, float[] tau, float[] work);
		//int Sorgbr(char vect, int m, int n, int k, float[] a, int lda, float[] tau, float[] work);
		//int Sorghr(int n, int[] ilo, int[] ihi, float[] a, int lda, float[] tau, float[] work);
		//int Sorgl2(int m, int n, int k, float[] a, int lda, float[] tau, float[] work);
		//int Sorglq(int m, int n, int k, float[] a, int lda, float[] tau, float[] work);
		//int Sorgql(int m, int n, int k, float[] a, int lda, float[] tau, float[] work);
		//int Sorgr2(int m, int n, int k, float[] a, int lda, float[] tau, float[] work);
		//int Sorgrq(int m, int n, int k, float[] a, int lda, float[] tau, float[] work);
		//int Sorgtr(char uplo, int n, float[] a, int lda, float[] tau, float[] work);
		//int Sorm2l(char side, char trans, int m, int n, int k, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Sorm2r(char side, char trans, int m, int n, int k, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Sormbr(char vect, char side, char trans, int m, int n, int k, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Sormhr(char side, char trans, int m, int n, int[] ilo, int[] ihi, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Sorml2(char side, char trans, int m, int n, int k, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Sormlq(char side, char trans, int m, int n, int k, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Sormql(char side, char trans, int m, int n, int k, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Sormr2(char side, char trans, int m, int n, int k, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Sormr3(char side, char trans, int m, int n, int k, int[] l, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Sormrq(char side, char trans, int m, int n, int k, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Sormrz(char side, char trans, int m, int n, int k, int[] l, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Sormtr(char side, char uplo, char trans, int m, int n, float[] a, int lda, float[] tau, float[] c, int ldc, float[] work);
		//int Spbcon(char uplo, int n, int[] kd, float[] ab, int ldab, float[] anorm, float[] rcond, float[] work, int iwork);
		//int Spbequ(char uplo, int n, int[] kd, float[] ab, int ldab, float[] s, float[] scond, float[] amax);
		//int Spbrfs(char uplo, int n, int[] kd, int nrhs, float[] ab, int ldab, float[] afb, int ldafb, float[] b, int ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work, int iwork);
		//int Spbstf(char uplo, int n, int[] kd, float[] ab, int ldab);
		//int Spbsv(char uplo, int n, int[] kd, int nrhs, float[] ab, int ldab, float[] b, int ldb);
		//int Spbsvx(char fact, char uplo, int n, int[] kd, int nrhs, float[] ab, int ldab, float[] afb, int ldafb, char equed, float[] s, float[] b, int ldb, float[] x, int ldx, float[] rcond, float[] ferr, float[] berr, float[] work, int iwork);
		//int Spbtf2(char uplo, int n, int[] kd, float[] ab, int ldab);
		//int Spbtrf(char uplo, int n, int[] kd, float[] ab, int ldab);
		//int Spbtrs(char uplo, int n, int[] kd, int nrhs, float[] ab, int ldab, float[] b, int ldb);
		//int Spocon(char uplo, int n, float[] a, int lda, float[] anorm, float[] rcond, float[] work, int iwork);
		//int Spoequ(int n, float[] a, int lda, float[] s, float[] scond, float[] amax);
		//int Sporfs(char uplo, int n, int nrhs, float[] a, int lda, float[] af, int ldaf, float[] b, int ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work, int iwork);
		//int Sposv(char uplo, int n, int nrhs, float[] a, int lda, float[] b, int ldb);
		//int Sposvx(char fact, char uplo, int n, int nrhs, float[] a, int lda, float[] af, int ldaf, char equed, float[] s, float[] b, int ldb, float[] x, int ldx, float[] rcond, float[] ferr, float[] berr, float[] work, int iwork);
		//int Spotf2(char uplo, int n, float[] a, int lda);
		//int Sppcon(char uplo, int n, float[] ap, float[] anorm, float[] rcond, float[] work, int iwork);
		//int Sppequ(char uplo, int n, float[] ap, float[] s, float[] scond, float[] amax);
		//int Spprfs(char uplo, int n, int nrhs, float[] ap, float[] afp, float[] b, int ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work, int iwork);
		//int Sppsv(char uplo, int n, int nrhs, float[] ap, float[] b, int ldb);
		//int Sppsvx(char fact, char uplo, int n, int nrhs, float[] ap, float[] afp, char equed, float[] s, float[] b, int ldb, float[] x, int ldx, float[] rcond, float[] ferr, float[] berr, float[] work, int iwork);
		//int Spptrf(char uplo, int n, float[] ap);
		//int Spptri(char uplo, int n, float[] ap);
		//int Spptrs(char uplo, int n, int nrhs, float[] ap, float[] b, int ldb);
		//int Sptcon(int n, float[] d, float[] e, float[] anorm, float[] rcond, float[] work);
		//int Spteqr(char compz, int n, float[] d, float[] e, float[] z, int ldz, float[] work);
		//int Sptrfs(int n, int nrhs, float[] d, float[] e, float[] df, float[] ef, float[] b, int ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work);
		//int Sptsv(int n, int nrhs, float[] d, float[] e, float[] b, int ldb);
		//int Sptsvx(char fact, int n, int nrhs, float[] d, float[] e, float[] df, float[] ef, float[] b, int ldb, float[] x, int[] ldx, float[] rcond, float[] ferr, float[] berr, float[] work);
		//int Spttrf(int n, float[] d, float[] e);
		//int Spttrs(int n, int nrhs, float[] d, float[] e, float[] b, int ldb);
		//int Sptts2(int n, int nrhs, float[] d, float[] e, float[] b, int ldb);
		//int Srscl(int n, float[] sa, float[] sx, int[] incx);
		//int Ssbev(char jobz, char uplo, int n, int[] kd, float[] ab, int ldab, float[] w, float[] z, int ldz, float[] work);
		//int Ssbevd(char jobz, char uplo, int n, int[] kd, float[] ab, int ldab, float[] w, float[] z, int ldz, float[] work, int iwork, int[] liwork);
		//int Ssbevx(char jobz, char range, char uplo, int n, int[] kd, float[] ab, int ldab, float[] q, int ldq, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, float[] z, int ldz, float[] work, int iwork, int[] ifail);
		//int Ssbgst(char vect, char uplo, int n, int[] ka, int[] kb, float[] ab, int ldab, float[] bb, int ldbb, float[] x, int ldx, float[] work);
		//int Ssbgv(char jobz, char uplo, int n, int[] ka, int[] kb, float[] ab, int ldab, float[] bb, int ldbb, float[] w, float[] z, int ldz, float[] work);
		//int Ssbgvd(char jobz, char uplo, int n, int[] ka, int[] kb, float[] ab, int ldab, float[] bb, int ldbb, float[] w, float[] z, int ldz, float[] work, int iwork, int[] liwork);
		//int Ssbgvx(char jobz, char range, char uplo, int n, int[] ka, int[] kb, float[] ab, int ldab, float[] bb, int ldbb, float[] q, int ldq, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, float[] z, int ldz, float[] work, int iwork, int[] ifail);
		//int Ssbtrd(char vect, char uplo, int n, int[] kd, float[] ab, int ldab, float[] d, float[] e, float[] q, int ldq, float[] work);
		//int Sspcon(char uplo, int n, float[] ap, int[] ipiv, float[] anorm, float[] rcond, float[] work, int iwork);
		//int Sspev(char jobz, char uplo, int n, float[] ap, float[] w, float[] z, int ldz, float[] work);
		//int Sspevd(char jobz, char uplo, int n, float[] ap, float[] w, float[] z, int ldz, float[] work, int iwork, int[] liwork);
		//int Sspevx(char jobz, char range, char uplo, int n, float[] ap, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, float[] z, int ldz, float[] work, int iwork, int[] ifail);
		//int Sspgst(int[] itype, char uplo, int n, float[] ap, float[] bp);
		//int Sspgv(int[] itype, char jobz, char uplo, int n, float[] ap, float[] bp, float[] w, float[] z, int ldz, float[] work);
		//int Sspgvd(int[] itype, char jobz, char uplo, int n, float[] ap, float[] bp, float[] w, float[] z, int ldz, float[] work, int iwork, int[] liwork);
		//int Sspgvx(int[] itype, char jobz, char range, char uplo, int n, float[] ap, float[] bp, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, float[] z, int ldz, float[] work, int iwork, int[] ifail);
		//int Ssprfs(char uplo, int n, int nrhs, float[] ap, float[] afp, int[] ipiv, float[] b, int ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work, int iwork, int[] info);
		//int Sspsv(char uplo, int n, int nrhs, float[] ap, int[] ipiv, float[] b, int ldb);
		//int Sspsvx(char fact, char uplo, int n, int nrhs, float[] ap, float[] afp, int[] ipiv, float[] b, int ldb, float[] x, int ldx, float[] rcond, float[] ferr, float[] berr, float[] work, int iwork);
		//int Ssptrd(char uplo, int n, float[] ap, float[] d, float[] e, float[] tau);
		//int Ssptrf(char uplo, int n, float[] ap, int[] ipiv);
		//int Ssptri(char uplo, int n, float[] ap, int[] ipiv, float[] work);
		//int Ssptrs(char uplo, int n, int nrhs, float[] ap, int[] ipiv, float[] b, int ldb);
		//int Sstebz(char range, char order, int n, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, float[] d, float[] e, int m, int[] nsplit, float[] w, int[] iblock, int[] isplit, float[] work, int iwork);
		//int Sstedc(char compz, int n, float[] d, float[] e, float[] z, int ldz, float[] work, int iwork, int[] liwork);
		//int Sstegr(char jobz, char range, int n, float[] d, float[] e, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, float[] z, int ldz, int[] isuppz, float[] work, int iwork, int[] liwork);
		//int Sstein(int n, float[] d, float[] e, int m, float[] w, int[] iblock, int[] isplit, float[] z, int ldz, float[] work, int iwork, int[] ifail);
		//int Ssteqr(char compz, int n, float[] d, float[] e, float[] z, int ldz, float[] work);
		//int Ssterf(int n, float[] d, float[] e);
		//int Sstev(char jobz, int n, float[] d, float[] e, float[] z, int ldz, float[] work);
		//int Sstevd(char jobz, int n, float[] d, float[] e, float[] z, int ldz, float[] work, int iwork, int[] liwork);
		//int Sstevr(char jobz, char range, int n, float[] d, float[] e, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, float[] z, int ldz, int[] isuppz, float[] work, int iwork, int[] liwork);
		//int Sstevx(char jobz, char range, int n, float[] d, float[] e, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, float[] z, int ldz, float[] work, int iwork, int[] ifail);
		//int Ssycon(char uplo, int n, float[] a, int lda, int[] ipiv, float[] anorm, float[] rcond, float[] work, int iwork);
		//int Ssyev(char jobz, char uplo, int n, float[] a, int lda, float[] w, float[] work);
		//int Ssyevd(char jobz, char uplo, int n, float[] a, int lda, float[] w, float[] work, int iwork, int[] liwork);
		//int Ssyevr(char jobz, char range, char uplo, int n, float[] a, int lda, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, float[] z, int ldz, int[] isuppz, float[] work, int iwork, int[] liwork);
		//int Ssyevx(char jobz, char range, char uplo, int n, float[] a, int lda, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, float[] z, int ldz, float[] work, int iwork, int[] ifail);
		//int Ssygs2(int[] itype, char uplo, int n, float[] a, int lda, float[] b, int ldb);
		//int Ssygst(int[] itype, char uplo, int n, float[] a, int lda, float[] b, int ldb);
		//int Ssygv(int[] itype, char jobz, char uplo, int n, float[] a, int lda, float[] b, int ldb, float[] w, float[] work);
		//int Ssygvd(int[] itype, char jobz, char uplo, int n, float[] a, int lda, float[] b, int ldb, float[] w, float[] work, int iwork, int[] liwork);
		//int Ssygvx(int[] itype, char jobz, char range, char uplo, int n, float[] a, int lda, float[] b, int ldb, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, float[] z, int ldz, float[] work, int iwork, int[] ifail);
		//int Ssyrfs(char uplo, int n, int nrhs, float[] a, int lda, float[] af, int ldaf, int[] ipiv, float[] b, int ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work, int iwork);
		//int Ssysv(char uplo, int n, int nrhs, float[] a, int lda, int[] ipiv, float[] b, int ldb, float[] work);
		//int Ssysvx(char fact, char uplo, int n, int nrhs, float[] a, int lda, float[] af, int ldaf, int[] ipiv, float[] b, int ldb, float[] x, int ldx, float[] rcond, float[] ferr, float[] berr, float[] work, int iwork, int[] info);
		//int Ssytd2(char uplo, int n, float[] a, int lda, float[] d, float[] e, float[] tau);
		//int Ssytf2(char uplo, int n, float[] a, int lda, int[] ipiv);
		//int Ssytrd(char uplo, int n, float[] a, int lda, float[] d, float[] e, float[] tau, float[] work, int[] info);
		//int Ssytrf(char uplo, int n, float[] a, int lda, int[] ipiv, float[] work);
		//int Ssytri(char uplo, int n, float[] a, int lda, int[] ipiv, float[] work);
		//int Ssytrs(char uplo, int n, int nrhs, float[] a, int lda, int[] ipiv, float[] b, int ldb);
		//int Stbcon(char norm, char uplo, char diag, int n, int[] kd, float[] ab, int ldab, float[] rcond, float[] work, int iwork);
		//int Stbrfs(char uplo, char trans, char diag, int n, int[] kd, int nrhs, float[] ab, int ldab, float[] b, int[] ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work, int iwork);
		//int Stbtrs(char uplo, char trans, char diag, int n, int[] kd, int nrhs, float[] ab, int ldab, float[] b, int[] ldb);
		//int Stgevc(char side, char howmny, bool[] select, int n, float[] a, int lda, float[] b, int ldb, float[] vl, int ldvl, float[] vr, int ldvr, int[] mm, int m, float[] work);
		//int Stgex2(bool[] wantq, bool[] wantz, int n, float[] a, int lda, float[] b, int ldb, float[] q, int ldq, float[] z, int ldz, int[] j1, int[] n1, int[] n2, float[] work);
		//int Stgexc(bool[] wantq, bool[] wantz, int n, float[] a, int lda, float[] b, int ldb, float[] q, int ldq, float[] z, int ldz, int[] ifst, int[] ilst, float[] work);
		//int Stgsen(int[] ijob, bool[] wantq, bool[] wantz, bool[] select, int n, float[] a, int lda, float[] b, int ldb, float[] alphar, float[] alphai, float[] beta, float[] q, int ldq, float[] z, int ldz, int m, float[] pl, float[] pr, float[] dif, float[] work, int iwork, int[] liwork, int[] info);
		//int Stgsja(char jobu, char jobv, char jobq, int m, int[] p, int n, int k, int[] l, float[] a, int lda, float[] b, int ldb, float[] tola, float[] tolb, float[] alpha, float[] beta, float[] u, int ldu, float[] v, int ldv, float[] q, int ldq, float[] work, int[] ncycle);
		//int Stgsna(char job, char howmny, bool[] select, int n, float[] a, int lda, float[] b, int ldb, float[] vl, int ldvl, float[] vr, int ldvr, float[] s, float[] dif, int[] mm, int m, float[] work, int iwork, int[] info);
		//int Stgsy2(char trans, int[] ijob, int m, int n, float[] a, int lda, float[] b, int ldb, float[] c, int ldc, float[] d, int ldd, float[] e, int lde, float[] f, int[] ldf, float[] scale, float[] rdsum, float[] rdscal, int iwork, int[] pq);
		//int Stgsyl(char trans, int[] ijob, int m, int n, float[] a, int lda, float[] b, int ldb, float[] c, int ldc, float[] d, int ldd, float[] e, int lde, float[] f, int[] ldf, float[] scale, float[] dif, float[] work, int iwork);
		//int Stpcon(char norm, char uplo, char diag, int n, float[] ap, float[] rcond, float[] work, int iwork);
		//int Stprfs(char uplo, char trans, char diag, int n, int nrhs, float[] ap, float[] b, int ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work, int iwork);
		//int Stptri(char uplo, char diag, int n, float[] ap);
		//int Stptrs(char uplo, char trans, char diag, int n, int nrhs, float[] ap, float[] b, int ldb);
		//int Strcon(char norm, char uplo, char diag, int n, float[] a, int lda, float[] rcond, float[] work, int iwork);
		//int Strevc(char side, char howmny, bool[] select, int n, float[] t, int ldt, float[] vl, int ldvl, float[] vr, int ldvr, int[] mm, int m, float[] work);
		//int Strexc(char compq, int n, float[] t, int ldt, float[] q, int ldq, int[] ifst, int[] ilst, float[] work);
		//int Strrfs(char uplo, char trans, char diag, int n, int nrhs, float[] a, int lda, float[] b, int ldb, float[] x, int ldx, float[] ferr, float[] berr, float[] work, int iwork);
		//int Strsen(char job, char compq, bool[] select, int n, float[] t, int ldt, float[] q, int ldq, float[] wr, float[] wi, int m, float[] s, float[] sep, float[] work, int iwork, int[] liwork);
		//int Strsna(char job, char howmny, bool[] select, int n, float[] t, int ldt, float[] vl, int ldvl, float[] vr, int ldvr, float[] s, float[] sep, int[] mm, int m, float[] work, int ldwork, int iwork);
		//int Strsyl(char trana, char tranb, int[] isgn, int m, int n, float[] a, int lda, float[] b, int ldb, float[] c, int ldc, float[] scale);
		//int Strti2(char uplo, char diag, int n, float[] a, int lda);
		//int Strtri(char uplo, char diag, int n, float[] a, int lda);
		//int Strtrs(char uplo, char trans, char diag, int n, int nrhs, float[] a, int lda, float[] b, int ldb, int[] info);
		//int Stzrqf(int m, int n, float[] a, int lda, float[] tau);
		//int Stzrzf(int m, int n, float[] a, int lda, float[] tau, float[] work);
		//int Ddisna(char job, int m, int n, double[] d, double[] sep);
		//int Dgbcon(char norm, int n, int kl, int ku, double[] ab, int ldab, int[] ipiv, double[] anorm, double[] rcond, double[] work, int iwork);
		//int Dgbequ(int m, int n, int kl, int ku, double[] ab, int ldab, double[] r, double[] c, double[] rowcnd, double[] colcnd, double[] amax, int[] info);
		//int Dgbrfs(char trans, int n, int kl, int ku, int nrhs, double[] ab, int ldab, double[] afb, int ldafb, int[] ipiv, double[] b, int ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dgbsv(int n, int kl, int ku, int nrhs, double[] ab, int ldab, int[] ipiv, double[] b, int ldb);
		//int Dgbsvx(char fact, char trans, int n, int kl, int ku, int nrhs, double[] ab, int ldab, double[] afb, int ldafb, int[] ipiv, char equed, double[] r, double[] c, double[] b, int ldb, double[] x, int ldx, double[] rcond, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dgbtf2(int m, int n, int kl, int ku, double[] ab, int ldab, int[] ipiv);
		//int Dgbtrf(int m, int n, int kl, int ku, double[] ab, int ldab, int[] ipiv);
		//int Dgbtrs(char trans, int n, int kl, int ku, int nrhs, double[] ab, int ldab, int[] ipiv, double[] b, int ldb);
		//int Dgebak(char job, char side, int n, int[] ilo, int[] ihi, double[] scale, int m, double[] v, int ldv);
		//int Dgebal(char job, int n, double[] a, int lda, int[] ilo, int[] ihi, double[] scale);
		//int Dgebd2(int m, int n, double[] a, int lda, double[] d, double[] e, double[] tauq, double[] taup, double[] work);
		//int Dgeequ(int m, int n, double[] a, int lda, double[] r, double[] c, double[] rowcnd, double[] colcnd, double[] amax);
		//int Dgees(char jobvs, char sort, L_fp select, int n, double[] a, int lda, int[] sdim, double[] wr, double[] wi, double[] vs, int ldvs, double[] work, bool[] bwork);
		//int Dgeesx(char jobvs, char sort, L_fp select, char sense, int n, double[] a, int lda, int[] sdim, double[] wr, double[] wi, double[] vs, int ldvs, double[] rconde, double[] rcondv, double[] work, int iwork, int[] liwork, bool[] bwork);
		//int Dgeev(char jobvl, char jobvr, int n, double[] a, int lda, double[] wr, double[] wi, double[] vl, int ldvl, double[] vr, int ldvr, double[] work);
		//int Dgeevx(char balanc, char jobvl, char jobvr, char sense, int n, double[] a, int lda, double[] wr, double[] wi, double[] vl, int ldvl, double[] vr, int ldvr, int[] ilo, int[] ihi, double[] scale, double[] abnrm, double[] rconde, double[] rcondv, double[] work, int iwork);
		//int Dgegs(char jobvsl, char jobvsr, int n, double[] a, int lda, double[] b, int ldb, double[] alphar, double[] alphai, double[] beta, double[] vsl, int ldvsl, double[] vsr, int ldvsr, double[] work);
		//int Dgegv(char jobvl, char jobvr, int n, double[] a, int lda, double[] b, int ldb, double[] alphar, double[] alphai, double[] beta, double[] vl, int ldvl, double[] vr, int ldvr, double[] work);
		//int Dgehd2(int n, int[] ilo, int[] ihi, double[] a, int lda, double[] tau, double[] work);
		//int Dgehrd(int n, int[] ilo, int[] ihi, double[] a, int lda, double[] tau, double[] work);
		//int Dgelq2(int m, int n, double[] a, int lda, double[] tau, double[] work);
		//int Dgelqf(int m, int n, double[] a, int lda, double[] tau, double[] work);
		//int Dgelsd(int m, int n, int nrhs, double[] a, int lda, double[] b, int ldb, double[] s, double[] rcond, int[] rank, double[] work, int iwork);
		//int Dgelsx(int m, int n, int nrhs, double[] a, int lda, double[] b, int ldb, int[] jpvt, double[] rcond, int[] rank);
		//int Dgelsx(int m, int n, int nrhs, double[] a, int lda, double[] b, int ldb, int[] jpvt, double[] rcond, int[] rank, double[] work);
		//int Dgeql2(int m, int n, double[] a, int lda, double[] tau, double[] work);
		//int Dgeqlf(int m, int n, double[] a, int lda, double[] tau, double[] work);
		//int Dgeqpf(int m, int n, double[] a, int lda, int[] jpvt, double[] tau, double[] work);
		//int Dgeqr2(int m, int n, double[] a, int lda, double[] tau, double[] work);
		//int Dgeqrf(int m, int n, double[] a, int lda, double[] tau, double[] work);
		//int Dgerfs(char trans, int n, int nrhs, double[] a, int lda, double[] af, int ldaf, int[] ipiv, double[] b, int ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dgerq2(int m, int n, double[] a, int lda, double[] tau, double[] work);
		//int Dgerqf(int m, int n, double[] a, int lda, double[] tau, double[] work);
		//int Dgesc2(int n, double[] a, int lda, double[] rightSide, int[] ipiv, int[] jpiv, double[] scale);
		//int Dgesdd(char jobz, int m, int n, double[] a, int lda, double[] s, double[] u, int ldu, double[] vt, int ldvt, double[] work, int iwork);
		//int Dgesv(int n, int nrhs, double[] a, int[] lda, int[] ipiv, double[] b, int ldb);
		//int Dgesvx(char fact, char trans, int n, int nrhs, double[] a, int lda, double[] af, int ldaf, int[] ipiv, char equed, double[] r, double[] c, double[] b, int ldb, double[] x, int ldx, double[] rcond, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dgetc2(int n, double[] a, int lda, int[] ipiv, int[] jpiv);
		//int Dgetf2(int m, int n, double[] a, int lda, int[] ipiv);
		//int Dggbak(char job, char side, int n, int[] ilo, int[] ihi, double[] lscale, double[] rscale, int m, double[] v, int ldv);
		//int Dggbal(char job, int n, double[] a, int lda, double[] b, int ldb, int[] ilo, int[] ihi, double[] lscale, double[] rscale, double[] work, int[] info);
		//int Dgges(char jobvsl, char jobvsr, char sort, L_fp delctg, int n, double[] a, int lda, double[] b, int ldb, int[] sdim, double[] alphar, double[] alphai, double[] beta, double[] vsl, int ldvsl, double[] vsr, int ldvsr, double[] work, bool[] bwork );
		//int Dggesx(char jobvsl, char jobvsr, char sort, L_fp delctg, char sense, int n, double[] a, int lda, double[] b, int ldb, int[] sdim, double[] alphar, double[] alphai, double[] beta, double[] vsl, int ldvsl, double[] vsr, int ldvsr, double[] rconde, double[] rcondv, double[] work, int iwork, int[] liwork, bool[] bwork);
		//int Dggevx(char balanc, char jobvl, char jobvr, char sense, int n, double[] a, int lda, double[] b, int ldb, double[] alphar, double[] alphai, double[] beta, double[] vl, int ldvl, double[] vr, int ldvr, int[] ilo, int[] ihi, double[] lscale, double[] rscale, double[] abnrm, double[] bbnrm, double[] rconde, double[] rcondv, double[] work, int iwork, bool[] bwork);
		//int Dggglm(int n, int m, int[] p, double[] a, int lda, double[] b, int ldb, double[] d, double[] x, double[] y, double[] work);
		//int Dgghrd(char compq, char compz, int n, int[] ilo, int[] ihi, double[] a, int lda, double[] b, int ldb, double[] q, int ldq, double[] z, int ldz);
		//int Dgglse(int m, int n, int[] p, double[] a, int lda, double[] b, int ldb, double[] c, double[] d, double[] x, double[] work);
		//int Dggqrf(int n, int m, int[] p, double[] a, int lda, double[] taua, double[] b, int ldb, double[] taub, double[] work);
		//int Dggrqf(int m, int[] p, int n, double[] a, int lda, double[] taua, double[] b, int ldb, double[] taub, double[] work);
		//int Dggsvd(char jobu, char jobv, char jobq, int m, int n, int[] p, int k, int[] l, double[] a, int lda, double[] b, int ldb, double[] alpha, double[] beta, double[] u, int ldu, double[] v, int[] ldv, double[] q, int ldq, double[] work, int iwork);
		//int Dggsvp(char jobu, char jobv, char jobq, int m, int[] p, int n, double[] a, int lda, double[] b, int ldb, double[] tola, double[] tolb, int k, int[] l, double[] u, int ldu, double[] v, int ldv, double[] q, int ldq, int iwork, double[] tau, double[] work);
		//int Dgtcon(char norm, int n, double[] dl, double[] d, double[] du, double[] du2, int[] ipiv, double[] anorm, double[] rcond, double[] work, int iwork);
		//int Dgtrfs(char trans, int n, int nrhs, double[] dl, double[] d, double[] du, double[] dlf, double[] df, double[] duf, double[] du2, int[] ipiv, double[] b, int ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work, int iwork, int[] info);
		//int Dgtsv(int n, int nrhs, double[] dl, double[] d, double[] du, double[] b, int ldb);
		//int Dgtsvx(char fact, char trans, int n, int nrhs, double[] dl, double[] d, double[] du, double[] dlf, double[] df, double[] duf, double[] du2, int[] ipiv, double[] b, int ldb, double[] x, int ldx, double[] rcond, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dgttrf(int n, double[] dl, double[] d, double[] du, double[] du2, int[] ipiv);
		//int Dgttrs(char trans, int n, int nrhs, double[] dl, double[] d, double[] du, double[] du2, int[] ipiv, double[] b, int ldb);
		//int Dgtts2(int[] itrans, int n, int nrhs, double[] dl, double[] d, double[] du, double[] du2, int[] ipiv, double[] b, int ldb);
		//int Dhgeqz(char job, char compq, char compz, int n, int[] ilo, int[] ihi, double[] a, int lda, double[] b, int ldb, double[] alphar, double[] alphai, double[] beta, double[] q, int ldq, double[] z, int ldz, double[] work);
		//int Dhsein(char side, char eigsrc, char initv, bool[] select, int n, double[] h, int ldh, double[] wr, double[] wi, double[] vl, int ldvl, double[] vr, int ldvr, int[] mm, int m, double[] work, int[] ifaill, int[] ifailr);
		//int Dhseqr(char job, char compz, int n, int[] ilo, int[] ihi, double[] h, int ldh, double[] wr, double[] wi, double[] z, int ldz, double[] work);
		//int Dlabad(double[] small, double[] large);
		//int Dlabrd(int m, int n, int[] nb, double[] a, int lda, double[] d, double[] e, double[] tauq, double[] taup, double[] x, int ldx, double[] y, int[] ldy);
		//int Dlacon(int n, double[] v, double[] x, int[] isgn, double[] est, int[] kase);
		//int Dlacpy(char uplo, int m, int n, double[] a, int lda, double[] b, int ldb);
		//int Dladiv(double[] a, double[] b, double[] c, double[] d, double[] p, double[] q);
		//int Dlae2(double[] a, double[] b, double[] c, double[] rt1, double[] rt2);
		//int Dlaebz(int[] ijob, int[] nitmax, int n, int[] mmax, int[] minp, int[] nbmin, double[] abstol, double[] reltol, double[] pivmin, double[] d, double[] e, double[] e2, int[] nval, double[] ab, double[] c, int[] mout, int[] nab, double[] work, int iwork);
		//int Dlaed0(int[] icompq, int[] qsiz, int n, double[] d, double[] e, double[] q, int ldq, double[] qstore, int ldqs, double[] work, int iwork);
		//int Dlaed1(int n, double[] d, double[] q, int ldq, int[] indxq, double[] rho, int[] cutpnt, double[] work, int iwork);
		//int Dlaed2(int k, int n, int[] n1, double[] d, double[] q, int ldq, int[] indxq, double[] rho, double[] z, double[] dlamda, double[] w, double[] q2, int[] indx, int[] indxc, int[] indxp, int[] coltyp);
		//int Dlaed3(int k, int n, int[] n1, double[] d, double[] q, int ldq, double[] rho, double[] dlamda, double[] q2, int[] indx, int[] ctot, double[] w, double[] s);
		//int Dlaed4(int n, int[] i, double[] d, double[] z, double[] delta, double[] rho, double[] dlam);
		//int Dlaed5(int[] i, double[] d, double[] z, double[] delta, double[] rho, double[] dlam);
		//int Dlaed6(int[] kniter, bool[] orgati, double[] rho, double[] d, double[] z, double[] finit, double[] tau);
		//int Dlaed7(int[] icompq, int n, int[] qsiz, int[] tlvls, int[] curlvl, int[] curpbm, double[] d, double[] q, int ldq, int[] indxq, double[] rho, int[] cutpnt, double[] qstore, int[] qptr, int[] prmptr, int[] perm, int[] givptr, int[] givcol, double[] givnum, double[] work, int iwork);
		//int Dlaed8(int[] icompq, int k, int n, int[] qsiz, double[] d, double[] q, int ldq, int[] indxq, double[] rho, int[] cutpnt, double[] z, double[] dlamda, double[] q2, int ldq2, double[] w, int[] perm, int[] givptr, int[] givcol, double[] givnum, int[] indxp, int[] indx);
		//int Dlaed9(int k, int[] kstart, int[] kstop, int n, double[] d, double[] q, int ldq, double[] rho, double[] dlamda, double[] w, double[] s, int lds);
		//int Dlaeda(int n, int[] tlvls, int[] curlvl, int[] curpbm, int[] prmptr, int[] perm, int[] givptr, int[] givcol, double[] givnum, double[] q, int[] qptr, double[] z, double[] ztemp);
		//int Dlaein(bool[] rightv, bool[] noinit, int n, double[] h, int ldh, double[] wr, double[] wi, double[] vr, double[] vi, double[] b, int ldb, double[] work, double[] eps3, double[] smlnum, double[] bignum);
		//int Dlaev2(double[] a, double[] b, double[] c, double[] rt1, double[] rt2, double[] cs1, double[] sn1);
		//int Dlaexc(bool[] wantq, int n, double[] t, int ldt, double[] q, int ldq, int[] j1, int[] n1, int[] n2, double[] work);
		//int Dlag2(double[] a, int lda, double[] b, int ldb, double[] safmin, double[] scale1, double[] scale2, double[] wr1, double[] wr2, double[] wi);
		//int Dlags2(bool[] upper, double[] a1, double[] a2, double[] a3, double[] b1, double[] b2, double[] b3, double[] csu, double[] snu, double[] csv, double[] snv, double[] csq, double[] snq);
		//int Dlagtf(int n, double[] a, double[] lambda, double[] b, double[] c, double[] tol, double[] d, int[] in);
		//int Dlagtm(char trans, int n, int nrhs, double[] alpha, double[] dl, double[] d, double[] du, double[] x, int ldx, double[] beta, double[] b, int[] ldb);
		//int Dlagts(int[] job, int n, double[] a, double[] b, double[] c, double[] d, int[] in, double[] y, double[] tol);
		//int Dlagv2(double[] a, int lda, double[] b, int ldb, double[] alphar, double[] alphai, double[] beta, double[] csl, double[] snl, double[] csr, double[] snr);
		//int Dlahqr(bool[] wantt, bool[] wantz, int n, int[] ilo, int[] ihi, double[] h, int ldh, double[] wr, double[] wi, int[] iloz, int[] ihiz, double[] z, int ldz);
		//int Dlahrd(int n, int k, int[] nb, double[] a, int lda, double[] tau, double[] t, int ldt, double[] y, int ldy);
		//int Dlaic1(int[] job, int[] j, double[] x, double[] sest, double[] w, double[] gamma, double[] sestpr, double[] s, double[] c);
		//int Dlaln2(bool[] ltrans, int[] na, int[] nw, double[] smin, double[] ca, double[] a, int lda, double[] d1, double[] d2, double[] b, int ldb, double[] wr, double[] wi, double[] x, int ldx, double[] scale, double[] xnorm);
		//int Dlals0(int[] icompq, int[] nl, int[] nr, int[] sqre, int nrhs, double[] b, int ldb, double[] bx, int ldbx, int[] perm, int[] givptr, int[] givcol, int ldgcol, double[] givnum, int ldgnum, double[] poles, double[] difl, double[] difr, double[] z, int k, double[] c, double[] s, double[] work);
		//int Dlalsa(int[] icompq, int[] smlsiz, int n, int nrhs, double[] b, int ldb, double[] bx, int ldbx, double[] u, int ldu, double[] vt, int k, double[] difl, double[] difr, double[] z, double[] poles, int[] givptr, int[] givcol, int ldgcol, int[] perm, double[] givnum, double[] c, double[] s, double[] work, int iwork);
		//int Dlalsd(char uplo, int[] smlsiz, int n, int nrhs, double[] d, double[] e, double[] b, int ldb, double[] rcond, int[] rank, double[] work, int iwork);
		//int Dlamc1(int[] beta, int[] t, bool[] rnd, bool[] ieee1);
		//int Dlamc2(int[] beta, int[] t, bool[] rnd, double[] eps, int[] emin, double[] rmin, int[] emax, double[] rmax);
		//int Dlamc4(int[] emin, double[] start, int[] base);
		//int Dlamc5(int[] beta, int[] p, int[] emin, bool[] ieee, int[] emax, double[] rmax);
		//int Dlamrg(int[] n1, int[] n2, double[] a, int[] dtrd1, int[] dtrd2, int[] index);
		//int Dlanv2(double[] a, double[] b, double[] c, double[] d, double[] rt1r, double[] rt1i, double[] rt2r, double[] rt2i, double[] cs, double[] sn);
		//int Dlapll(int n, double[] x, int[] incx, double[] y, int[] incy, double[] ssmin);
		//int Dlapmt(bool[] forwrd, int m, int n, double[] x, int ldx, int k);
		//int Dlaqgb(int m, int n, int kl, int ku, double[] ab, int ldab, double[] r, double[] c, double[] rowcnd, double[] colcnd, double[] amax, char equed);
		//int Dlaqge(int m, int n, double[] a, int lda, double[] r, double[] c, double[] rowcnd, double[] colcnd, double[] amax, char equed);
		//int Dlaqp2(int m, int n, int[] offset, double[] a, int lda, int[] jpvt, double[] tau, double[] vn1, double[] vn2, double[] work);
		//int Dlaqps(int m, int n, int[] offset, int[] nb, int[] kb, double[] a, int lda, int[] jpvt, double[] tau, double[] vn1, double[] vn2, double[] auxv, double[] f, int ldf);
		//int Dlaqsb(char uplo, int n, int[] kd, double[] ab, int ldab, double[] s, double[] scond, double[] amax, char equed);
		//int Dlaqsp(char uplo, int n, double[] ap, double[] s, double[] scond, double[] amax, char equed);
		//int Dlaqsy(char uplo, int n, double[] a, int lda, double[] s, double[] scond, double[] amax, char equed);
		//int Dlaqtr(bool[] ltran, bool[] lreal, int n, double[] t, int ldt, double[] b, double[] w, double[] scale, double[] x, double[] work);
		//int Dlar1v(int n, int[] b1, int[] bn, double[] sigma, double[] d, double[] l, double[] ld, double[] lld, double[] gersch, double[] z, double[] ztz, double[] mingma, int[] r, int[] isuppz, double[] work);
		//int Dlar2v(int n, double[] x, double[] y, double[] z, int[] incx, double[] c, double[] s, int[] incc);
		//int Dlarf(char side, int m, int n, double[] v, int[] incv, double[] tau, double[] c, int ldc, double[] work);
		//int Dlarfb(char side, char trans, char direct, char storev, int m, int n, int k, double[] v, int ldv, double[] t, int ldt, double[] c, int ldc, double[] work, int ldwork);
		//int Dlarfg(int n, double[] alpha, double[] x, int[] incx, double[] tau);
		//int Dlarft(char direct, char storev, int n, int k, double[] v, int ldv, double[] tau, double[] t, int ldt);
		//int Dlarfx(char side, int m, int n, double[] v, double[] tau, double[] c, int ldc, double[] work);
		//int Dlargv(int n, double[] x, int[] incx, double[] y, int[] incy, double[] c, int[] incc);
		//int Dlarnv(int[] idist, int[] iseed, int n, double[] x);
		//int Dlarrb(int n, double[] d, double[] l, double[] ld, double[] lld, int[] ifirst, int[] ilast, double[] sigma, double[] reltol, double[] w, double[] wgap, double[] werr, double[] work, int iwork, int[] info);
		//int Dlarre(int n, double[] d, double[] e, double[] tol, int[] nsplit, int[] isplit, int m, double[] w, double[] woff, double[] gersch, double[] work);
		//int Dlarrf(int n, double[] d, double[] l, double[] ld, double[] lld, int[] ifirst, int[] ilast, double[] w, double[] dplus, double[] lplus, double[] work, int iwork);
		//int Dlarrv(int n, double[] d, double[] l, int[] isplit, int m, double[] w, int[] iblock, double[] gersch, double[] tol, double[] z, int ldz, int[] isuppz, double[] work, int iwork);
		//int Dlartg(double[] f, double[] g, double[] cs, double[] sn, double[] r);
		//int Dlartv(int n, double[] x, int[] incx, double[] y, int[] incy, double[] c, double[] s, int[] incc);
		//int Dlaruv(int[] iseed, int n, double[] x);
		//int Dlarz(char side, int m, int n, int[] l, double[] v, int[] incv, double[] tau, double[] c, int ldc, double[] work);
		//int Dlarzb(char side, char trans, char direct, char storev, int m, int n, int k, int[] l, double[] v, int ldv, double[] t, int ldt, double[] c, int ldc, double[] work, int ldwork);
		//int Dlarzt(char direct, char storev, int n, int k, double[] v, int ldv, double[] tau, double[] t, int ldt);
		//int Dlas2(double[] f, double[] g, double[] h, double[] ssmin, double[] ssmax);
		//int Dlascl(char type, int kl, int ku, double[] cfrom, double[] cto, int m, int n, double[] a, int lda);
		//int Dlasd0(int n, int[] sqre, double[] d, double[] e, double[] u, int ldu, double[] vt, int ldvt, int[] smlsiz, int iwork, double[] work, int[] info);
		//int Dlasd1(int[] nl, int[] nr, int[] sqre, double[] d, double[] alpha, double[] beta, double[] u, int ldu, double[] vt, int ldvt, int[] idxq, int iwork, double[] work);
		//int Dlasd2(int[] nl, int[] nr, int[] sqre, int k, double[] d, double[] z, double[] alpha, double[] beta, double[] u, int ldu, double[] vt, int ldvt, double[] dsigma, double[] u2, int ldu2, double[] vt2, int ldvt2, int[] idxp, int[] idx, int[] idxc, int[] idxq, int[] coltyp);
		//int Dlasd3(int[] nl, int[] nr, int[] sqre, int k, double[] d, double[] q, int ldq, double[] dsigma, double[] u, int ldu, double[] u2, int ldu2, double[] vt, int ldvt, double[] vt2, int ldvt2, int[] idxc, int[] ctot, double[] z);
		//int Dlasd4(int n, int[] i, double[] d, double[] z, double[] delta, double[] rho, double[] sigma, double[] work);
		//int Dlasd5(int[] i, double[] d, double[] z, double[] delta, double[] rho, double[] dsigma, double[] work);
		//int Dlasd6(int[] icompq, int[] nl, int[] nr, int[] sqre, double[] d, double[] vf, double[] vl, double[] alpha, double[] beta, int[] idxq, int[] perm, int[] givptr, int[] givcol, int ldgcol, double[] givnum, int ldgnum, double[] poles, double[] difl, double[] difr, double[] z, int k, double[] c, double[] s, double[] work, int iwork);
		//int Dlasd7(int[] icompq, int[] nl, int[] nr, int[] sqre, int k, double[] d, double[] z, double[] zw, double[] vf, double[] vfw, double[] vl, double[] vlw, double[] alpha, double[] beta, double[] dsigma, int[] idx, int[] idxp, int[] idxq, int[] perm, int[] givptr, int[] givcol, int ldgcol, double[] givnum, int ldgnum, double[] c, double[] s);
		//int Dlasd8(int[] icompq, int k, double[] d, double[] z, double[] vf, double[] vl, double[] difl, double[] difr, int lddifr, double[] dsigma, double[] work);
		//int Dlasd9(int[] icompq, int ldu, int k, double[] d, double[] z, double[] vf, double[] vl, double[] difl, double[] difr, double[] dsigma, double[] work);
		//int Dlasda(int[] icompq, int[] smlsiz, int n, int[] sqre, double[] d, double[] e, double[] u, int[] ldu, double[] vt, int k, double[] difl, double[] difr, double[] z, double[] poles, int[] givptr, int[] givcol, int ldgcol, int[] perm, double[] givnum, double[] c, double[] s, double[] work, int iwork);
		//int Dlasdq(char uplo, int[] sqre, int n, int[] ncvt, int[] nru, int[] ncc, double[] d, double[] e, double[] vt, int ldvt, double[] u, int ldu, double[] c, int ldc, double[] work);
		//int Dlasdt(int n, int[] lvl, int[] nd, int[] inode, int[] ndiml, int[] ndimr, int[] msub);
		//int Dlaset(char uplo, int m, int n, double[] alpha, double[] beta, double[] a, int lda);
		//int Dlasq1(int n, double[] d, double[] e, double[] work);
		//int Dlasq2(int n, double[] z);
		//int Dlasq3(int[] i0, int[] n0, double[] z, int[] pp, double[] dmin, double[] sigma, double[] desig, double[] qmax, int[] nfail, int[] iter, int[] ndiv, bool[] ieee);
		//int Dlasq4(int[] i0, int[] n0, double[] z, int[] pp, int[] n0in, double[] dmin, double[] dmin1, double[] dmin2, double[] dn, double[] dn1, double[] dn2, double[] tau, int[] ttype);
		//int Dlasq5(int[] i0, int[] n0, double[] z, int[] pp, double[] tau, double[] dmin, double[] dmin1, double[] dmin2, double[] dn, double[] dnm1, double[] dnm2, bool[] ieee);
		//int Dlasq6(int[] i0, int[] n0, double[] z, int[] pp, double[] dmin, double[] dmin1, double[] dmin2, double[] dn, double[] dnm1, double[] dnm2);
		//int Dlasr(char side, char pivot, char direct, int m, int n, double[] c, double[] s, double[] a, int lda);
		//int Dlasrt(char id, int n, double[] d, int[] info);
		//int Dlassq(int n, double[] x, int[] incx, double[] scale, double[] sumsq);
		//int Dlasv2(double[] f, double[] g, double[] h, double[] ssmin, double[] ssmax, double[] snr, double[] csr, double[] snl, double[] csl);
		//int Dlaswp(int n, double[] a, int lda, int[] k1, int[] k2, int[] ipiv, int[] incx);
		//int Dlasy2(bool[] ltranl, bool[] ltranr, int[] isgn, int[] n1, int[] n2, double[] tl, int ldtl, double[] tr, int ldtr, double[] b, int ldb, double[] scale, double[] x, int ldx, double[] xnorm);
		//int Dlasyf(char uplo, int n, int[] nb, int[] kb, double[] a, int lda, int[] ipiv, double[] w, int ldw);
		//int Dlatbs(char uplo, char trans, char diag, char normin, int n, int[] kd, double[] ab, int ldab, double[] x, double[] scale, double[] cnorm);
		//int Dlatdf(int[] ijob, int n, double[] z, int ldz, double[] rightSide, double[] rdsum, double[] rdscal, int[] ipiv, int[] jpiv);
		//int Dlatps(char uplo, char trans, char diag, char normin, int n, double[] ap, double[] x, double[] scale, double[] cnorm);
		//int Dlatrd(char uplo, int n, int[] nb, double[] a, int lda, double[] e, double[] tau, double[] w, int ldw);
		//int Dlatrs(char uplo, char trans, char diag, char normin, int n, double[] a, int lda, double[] x, double[] scale, double[] cnorm);
		//int Dlatrz(int m, int n, int[] l, double[] a, int lda, double[] tau, double[] work);
		//int Dlatzm(char side, int m, int n, double[] v, int[] incv, double[] tau, double[] c1, double[] c2, int ldc, double[] work);
		//int Dlauu2(char uplo, int n, double[] a, int lda);
		//int Dlauum(char uplo, int n, double[] a, int lda);
		//int Dopgtr(char uplo, int n, double[] ap, double[] tau, double[] q, int ldq, double[] work);
		//int Dopmtr(char side, char uplo, char trans, int m, int n, double[] ap, double[] tau, double[] c, int[] ldc, double[] work);
		//int Dorg2l(int m, int n, int k, double[] a, int lda, double[] tau, double[] work);
		//int Dorg2r(int m, int n, int k, double[] a, int lda, double[] tau, double[] work);
		//int Dorgbr(char vect, int m, int n, int k, double[] a, int lda, double[] tau, double[] work);
		//int Dorghr(int n, int[] ilo, int[] ihi, double[] a, int lda, double[] tau, double[] work);
		//int Dorgl2(int m, int n, int k, double[] a, int lda, double[] tau, double[] work);
		//int Dorglq(int m, int n, int k, double[] a, int lda, double[] tau, double[] work);
		//int Dorgql(int m, int n, int k, double[] a, int lda, double[] tau, double[] work);
		//int Dppcon(char uplo, int n, double[] ap, double[] anorm, double[] rcond, double[] work, int iwork);
		//int Dorgr2(int m, int n, int k, double[] a, int lda, double[] tau, double[] work);
		//int Dorgrq(int m, int n, int k, double[] a, int lda, double[] tau, double[] work);
		//int Dorgtr(char uplo, int n, double[] a, int lda, double[] tau, double[] work);
		//int Dorm2l(char side, char trans, int m, int n, int k, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dorm2r(char side, char trans, int m, int n, int k, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dormbr(char vect, char side, char trans, int m, int n, int k, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dormhr(char side, char trans, int m, int n, int[] ilo, int[] ihi, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dorml2(char side, char trans, int m, int n, int k, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dormlq(char side, char trans, int m, int n, int k, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dormql(char side, char trans, int m, int n, int k, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dormr2(char side, char trans, int m, int n, int k, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dormr3(char side, char trans, int m, int n, int k, int[] l, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dormrq(char side, char trans, int m, int n, int k, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dormrz(char side, char trans, int m, int n, int k, int[] l, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dormtr(char side, char uplo, char trans, int m, int n, double[] a, int lda, double[] tau, double[] c, int ldc, double[] work);
		//int Dpbcon(char uplo, int n, int[] kd, double[] ab, int ldab, double[] anorm, double[] rcond, double[] work, int iwork);
		//int Dpbequ(char uplo, int n, int[] kd, double[] ab, int ldab, double[] s, double[] scond, double[] amax);
		//int Dpbrfs(char uplo, int n, int[] kd, int nrhs, double[] ab, int ldab, double[] afb, int ldafb, double[] b, int ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work, int iwork, int[] info);
		//int Dpbstf(char uplo, int n, int[] kd, double[] ab, int ldab);
		//int Dpbsv(char uplo, int n, int[] kd, int nrhs, double[] ab, int ldab, double[] b, int ldb);
		//int Dpbsvx(char fact, char uplo, int n, int[] kd, int nrhs, double[] ab, int ldab, double[] afb, int ldafb, char equed, double[] s, double[] b, int ldb, double[] x, int ldx, double[] rcond, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dpbtf2(char uplo, int n, int[] kd, double[] ab, int ldab);
		//int Dpbtrf(char uplo, int n, int[] kd, double[] ab, int ldab);
		//int Dpbtrs(char uplo, int n, int[] kd, int nrhs, double[] ab, int ldab, double[] b, int ldb);
		//int Dpocon(char uplo, int n, double[] a, int lda, double[] anorm, double[] rcond, double[] work, int iwork);
		//int Dpoequ(int n, double[] a, int lda, double[] s, double[] scond, double[] amax);
		//int Dporfs(char uplo, int n, int nrhs, double[] a, int lda, double[] af, int ldaf, double[] b, int ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work, int iwork, int[] info);
		//int Dposv(char uplo, int n, int nrhs, double[] a, int lda, double[] b, int ldb);
		//int Dposvx(char fact, char uplo, int n, int nrhs, double[] a, int lda, double[] af, int ldaf, char equed, double[] s, double[] b, int ldb, double[] x, int ldx, double[] rcond, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dpotf2(char uplo, int n, double[] a, int lda);
		//int Dppequ(char uplo, int n, double[] ap, double[] s, double[] scond, double[] amax);
		//int Dpprfs(char uplo, int n, int nrhs, double[] ap, double[] afp, double[] b, int ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dppsv(char uplo, int n, int nrhs, double[] ap, double[] b, int ldb);
		//int Dppsvx(char fact, char uplo, int n, int nrhs, double[] ap, double[] afp, char equed, double[] s, double[] b, int ldb, double[] x, int ldx, double[] rcond, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dpptrf(char uplo, int n, double[] ap, int[] info);
		//int Dpptri(char uplo, int n, double[] ap, int[] info);
		//int Dpptrs(char uplo, int n, int nrhs, double[] ap, double[] b, int ldb);
		//int Dptcon(int n, double[] d, double[] e, double[] anorm, double[] rcond, double[] work);
		//int Dpteqr(char compz, int n, double[] d, double[] e, double[] z, int ldz, double[] work);
		//int Dptrfs(int n, int nrhs, double[] d, double[] e, double[] df, double[] ef, double[] b, int[] ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work);
		//int Dptsv(int n, int nrhs, double[] d, double[] e, double[] b, int ldb);
		//int Dptsvx(char fact, int n, int nrhs, double[] d, double[] e, double[] df, double[] ef, double[] b, int ldb, double[] x, int ldx, double[] rcond, double[] ferr, double[] berr, double[] work, int[] info);
		//int Dpttrf(int n, double[] d, double[] e);
		//int Dpttrs(int n, int nrhs, double[] d, double[] e, double[] b, int ldb);
		//int Dptts2(int n, int nrhs, double[] d, double[] e, double[] b, int ldb);
		//int Drscl(int n, double[] sa, double[] sx, int[] incx);
		//int Dsbev(char jobz, char uplo, int n, int[] kd, double[] ab, int ldab, double[] w, double[] z, int ldz, double[] work);
		//int Dsbevd(char jobz, char uplo, int n, int[] kd, double[] ab, int ldab, double[] w, double[] z, int ldz, double[] work, int iwork, int[] liwork);
		//int Dsbevx(char jobz, char range, char uplo, int n, int[] kd, double[] ab, int ldab, double[] q, int ldq, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, double[] z, int ldz, double[] work, int iwork, int[] ifail);
		//int Dsbgst(char vect, char uplo, int n, int[] ka, int[] kb, double[] ab, int ldab, double[] bb, int ldbb, double[] x, int ldx, double[] work);
		//int Dsbgv(char jobz, char uplo, int n, int[] ka, int[] kb, double[] ab, int ldab, double[] bb, int ldbb, double[] w, double[] z, int ldz, double[] work);
		//int Dsbgvd(char jobz, char uplo, int n, int[] ka, int[] kb, double[] ab, int ldab, double[] bb, int ldbb, double[] w, double[] z, int ldz, double[] work, int iwork, int[] liwork);
		//int Dsbgvx(char jobz, char range, char uplo, int n, int[] ka, int[] kb, double[] ab, int ldab, double[] bb, int ldbb, double[] q, int ldq, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, double[] z, int ldz, double[] work, int iwork, int[] ifail);
		//int Dsbtrd(char vect, char uplo, int n, int[] kd, double[] ab, int ldab, double[] d, double[] e, double[] q, int ldq, double[] work);
		//int Dspcon(char uplo, int n, double[] ap, int[] ipiv, double[] anorm, double[] rcond, double[] work, int iwork);
		//int Dspev(char jobz, char uplo, int n, double[] ap, double[] w, double[] z, int ldz, double[] work);
		//int Dspevd(char jobz, char uplo, int n, double[] ap, double[] w, double[] z, int ldz, double[] work, int iwork, int[] liwork);
		//int Dspevx(char jobz, char range, char uplo, int n, double[] ap, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, double[] z, int ldz, double[] work, int iwork, int[] ifail);
		//int Dspgst(int[] itype, char uplo, int n, double[] ap, double[] bp);
		//int Dspgv(int[] itype, char jobz, char uplo, int n, double[] ap, double[] bp, double[] w, double[] z, int ldz, double[] work);
		//int Dspgvd(int[] itype, char jobz, char uplo, int n, double[] ap, double[] bp, double[] w, double[] z, int ldz, double[] work, int iwork, int[] liwork);
		//int Dspgvx(int[] itype, char jobz, char range, char uplo, int n, double[] ap, double[] bp, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, double[] z, int ldz, double[] work, int iwork, int[] ifail);
		//int Dsprfs(char uplo, int n, int nrhs, double[] ap, double[] afp, int[] ipiv, double[] b, int ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dspsv(char uplo, int n, int nrhs, double[] ap, int[] ipiv, double[] b, int ldb);
		//int Dspsvx(char fact, char uplo, int n, int nrhs, double[] ap, double[] afp, int[] ipiv, double[] b, int ldb, double[] x, int ldx, double[] rcond, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dsptrd(char uplo, int n, double[] ap, double[] d, double[] e, double[] tau);
		//int Dsptrf(char uplo, int n, double[] ap, int[] ipiv);
		//int Dsptri(char uplo, int n, double[] ap, int[] ipiv, double[] work);
		//int Dsptrs(char uplo, int n, int nrhs, double[] ap, int[] ipiv, double[] b, int ldb, int[] info);
		//int Dstebz(char range, char order, int n, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, double[] d, double[] e, int m, int[] nsplit, double[] w, int[] iblock, int[] isplit, double[] work, int iwork);
		//int Dstedc(char compz, int n, double[] d, double[] e, double[] z, int ldz, double[] work, int iwork, int[] liwork);
		//int Dstegr(char jobz, char range, int n, double[] d, double[] e, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, double[] z, int ldz, int[] isuppz, double[] work, int iwork, int[] liwork);
		//int Dstein(int n, double[] d, double[] e, int m, double[] w, int[] iblock, int[] isplit, double[] z, int ldz, double[] work, int iwork, int[] ifail);
		//int Dsteqr(char compz, int n, double[] d, double[] e, double[] z, int ldz, double[] work);
		//int Dsterf(int n, double[] d, double[] e);
		//int Dstev(char jobz, int n, double[] d, double[] e, double[] z, int ldz, double[] work);
		//int Dstevd(char jobz, int n, double[] d, double[] e, double[] z, int ldz, double[] work, int iwork, int[] liwork);
		//int Dstevr(char jobz, char range, int n, double[] d, double[] e, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, double[] z, int ldz, int[] isuppz, double[] work, int iwork, int[] liwork);
		//int Dstevx(char jobz, char range, int n, double[] d, double[] e, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, double[] z, int ldz, double[] work, int iwork, int[] ifail);
		//int Dsycon(char uplo, int n, double[] a, int lda, int[] ipiv, double[] anorm, double[] rcond, double[] work, int iwork);
		//int Dsyev(char jobz, char uplo, int n, double[] a, int lda, double[] w, double[] work);
		//int Dsyevd(char jobz, char uplo, int n, double[] a, int lda, double[] w, double[] work, int iwork, int[] liwork);
		//int Dsyevr(char jobz, char range, char uplo, int n, double[] a, int lda, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, double[] z, int ldz, int[] isuppz, double[] work, int iwork, int[] liwork);
		//int Dsyevx(char jobz, char range, char uplo, int n, double[] a, int lda, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, double[] z, int ldz, double[] work, int iwork, int[] ifail);
		//int Dsygs2(int[] itype, char uplo, int n, double[] a, int lda, double[] b, int ldb, int[] info);
		//int Dsygst(int[] itype, char uplo, int n, double[] a, int lda, double[] b, int ldb, int[] info);
		//int Dsygv(int[] itype, char jobz, char uplo, int n, double[] a, int lda, double[] b, int ldb, double[] w, double[] work);
		//int Dsygvd(int[] itype, char jobz, char uplo, int n, double[] a, int lda, double[] b, int ldb, double[] w, double[] work, int iwork, int[] liwork);
		//int Dsygvx(int[] itype, char jobz, char range, char uplo, int n, double[] a, int lda, double[] b, int[] ldb, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, double[] z, int ldz, double[] work, int iwork, int[] ifail);
		//int Dsyrfs(char uplo, int n, int nrhs, double[] a, int lda, double[] af, int ldaf, int[] ipiv, double[] b, int ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dsysv(char uplo, int n, int nrhs, double[] a, int lda, int[] ipiv, double[] b, int ldb, double[] work);
		//int Dsysvx(char fact, char uplo, int n, int nrhs, double[] a, int lda, double[] af, int ldaf, int[] ipiv, double[] b, int ldb, double[] x, int ldx, double[] rcond, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dsytd2(char uplo, int n, double[] a, int lda, double[] d, double[] e, double[] tau);
		//int Dsytf2(char uplo, int n, double[] a, int lda, int[] ipiv);
		//int Dsytrd(char uplo, int n, double[] a, int lda, double[] d, double[] e, double[] tau, double[] work);
		//int Dsytrf(char uplo, int n, double[] a, int lda, int[] ipiv, double[] work);
		//int Dsytri(char uplo, int n, double[] a, int lda, int[] ipiv, double[] work);
		//int Dsytrs(char uplo, int n, int nrhs, double[] a, int lda, int[] ipiv, double[] b, int ldb);
		//int Dtbcon(char norm, char uplo, char diag, int n, int[] kd, double[] ab, int ldab, double[] rcond, double[] work, int iwork);
		//int Dtbrfs(char uplo, char trans, char diag, int n, int[] kd, int nrhs, double[] ab, int ldab, double[] b, int ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dtbtrs(char uplo, char trans, char diag, int n, int[] kd, int nrhs, double[] ab, int ldab, double[] b, int ldb);
		//int Dtgevc(char side, char howmny, bool[] select, int n, double[] a, int lda, double[] b, int ldb, double[] vl, int ldvl, double[] vr, int ldvr, int[] mm, int m, double[] work);
		//int Dtgex2(bool[] wantq, bool[] wantz, int n, double[] a, int lda, double[] b, int ldb, double[] q, int ldq, double[] z, int ldz, int[] j1, int[] n1, int[] n2, double[] work);
		//int Dtgexc(bool[] wantq, bool[] wantz, int n, double[] a, int lda, double[] b, int ldb, double[] q, int ldq, double[] z, int ldz, int[] ifst, int[] ilst, double[] work);
		//int Dtgsen(int[] ijob, bool[] wantq, bool[] wantz, bool[] select, int n, double[] a, int lda, double[] b, int ldb, double[] alphar, double[] alphai, double[] beta, double[] q, int ldq, double[] z, int ldz, int m, double[] pl, double[] pr, double[] dif, double[] work, int iwork, int[] liwork);
		//int Dtgsja(char jobu, char jobv, char jobq, int m, int[] p, int n, int k, int[] l, double[] a, int lda, double[] b, int ldb, double[] tola, double[] tolb, double[] alpha, double[] beta, double[] u, int ldu, double[] v, int ldv, double[] q, int ldq, double[] work, int[] ncycle);
		//int Dtgsna(char job, char howmny, bool[] select, int n, double[] a, int lda, double[] b, int ldb, double[] vl, int ldvl, double[] vr, int ldvr, double[] s, double[] dif, int[] mm, int m, double[] work, int iwork);
		//int Dtgsy2(char trans, int[] ijob, int m, int n, double[] a, int lda, double[] b, int ldb, double[] c, int ldc, double[] d, int ldd, double[] e, int lde, double[] f, int ldf, double[] scale, double[] rdsum, double[] rdscal, int iwork, int[] pq);
		//int Dtgsyl(char trans, int[] ijob, int m, int n, double[] a, int lda, double[] b, int ldb, double[] c, int ldc, double[] d, int ldd, double[] e, int lde, double[] f, int ldf, double[] scale, double[] dif, double[] work, int iwork);
		//int Dtpcon(char norm, char uplo, char diag, int n, double[] ap, double[] rcond, double[] work, int iwork);
		//int Dtprfs(char uplo, char trans, char diag, int n, int nrhs, double[] ap, double[] b, int ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dtptri(char uplo, char diag, int n, double[] ap);
		//int Dtptrs(char uplo, char trans, char diag, int n, int nrhs, double[] ap, double[] b, int ldb, int[] info);
		//int Dtrcon(char norm, char uplo, char diag, int n, double[] a, int lda, double[] rcond, double[] work, int iwork);
		//int Dtrevc(char side, char howmny, bool[] select, int n, double[] t, int ldt, double[] vl, int ldvl, double[] vr, int ldvr, int[] mm, int m, double[] work);
		//int Dtrexc(char compq, int n, double[] t, int ldt, double[] q, int ldq, int[] ifst, int[] ilst, double[] work);
		//int Dtrrfs(char uplo, char trans, char diag, int n, int nrhs, double[] a, int lda, double[] b, int ldb, double[] x, int ldx, double[] ferr, double[] berr, double[] work, int iwork);
		//int Dtrsen(char job, char compq, bool[] select, int n, double[] t, int ldt, double[] q, int ldq, double[] wr, double[] wi, int m, double[] s, double[] sep, double[] work, int iwork, int[] liwork);
		//int Dtrsna(char job, char howmny, bool[] select, int n, double[] t, int ldt, double[] vl, int ldvl, double[] vr, int ldvr, double[] s, double[] sep, int[] mm, int m, double[] work, int ldwork, int iwork);
		//int Dtrsyl(char trana, char tranb, int[] isgn, int m, int n, double[] a, int lda, double[] b, int ldb, double[] c, int ldc, double[] scale);
		//int Dtrti2(char uplo, char diag, int n, double[] a, int lda);
		//int Dtrtri(char uplo, char diag, int n, double[] a, int lda);
		//int Dtrtrs(char uplo, char trans, char diag, int n, int nrhs, double[] a, int lda, double[] b, int ldb);
		//int Dtzrqf(int m, int n, double[] a, int lda, double[] tau);
		//int Dtzrzf(int m, int n, double[] a, int lda, double[] tau, double[] work);
		//int Cgbcon(char norm, int n, int kl, int ku, ComplexFloat[] ab, int ldab, int[] ipiv, float[] anorm, float[] rcond, ComplexFloat[] work, float[] rwork);
		//int Cgbequ(int m, int n, int kl, int ku, ComplexFloat[] ab, int ldab, float[] r, float[] c, float[] rowcnd, float[] colcnd, float[] amax);
		//int Cgbrfs(char trans, int n, int kl, int ku, int nrhs, ComplexFloat[] ab, int ldab, ComplexFloat[] afb, int ldafb, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cgbsv(int n, int kl, int ku, int nrhs, ComplexFloat[] ab, int ldab, int[] ipiv, ComplexFloat[] b, int ldb);
		//int Cgbsvx(char fact, char trans, int n, int kl, int ku, int nrhs, ComplexFloat[] ab, int ldab, ComplexFloat[] afb, int ldafb, int[] ipiv, char equed, float[] r, float[] c, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] rcond, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cgbtf2(int m, int n, int kl, int ku, ComplexFloat[] ab, int ldab, int[] ipiv);
		//int Cgbtrf(int m, int n, int kl, int ku, ComplexFloat[] ab, int ldab, int[] ipiv);
		//int Cgbtrs(char trans, int n, int kl, int ku, int nrhs, ComplexFloat[] ab, int ldab, int[] ipiv, ComplexFloat[] b, int ldb);
		//int Cgebak(char job, char side, int n, int[] ilo, int[] ihi, float[] scale, int m, ComplexFloat[] v, int ldv);
		//int Cgebal(char job, int n, ComplexFloat[] a, int lda, int[] ilo, int[] ihi, float[] scale);
		//int Cgebd2(int m, int n, ComplexFloat[] a, int lda, float[] d, float[] e, ComplexFloat[] tauq, ComplexFloat[] taup, ComplexFloat[] work);
		//int Cgeequ(int m, int n, ComplexFloat[] a, int lda, float[] r, float[] c, float[] rowcnd, float[] colcnd, float[] amax);
		//int Cgees(char jobvs, char sort, L_fp select, int n, ComplexFloat[] a, int lda, int[] sdim, ComplexFloat[] w, ComplexFloat[] vs, int ldvs, ComplexFloat[] work, float[] rwork, bool[] bwork);
		//int Cgeesx(char jobvs, char sort, L_fp select, char sense, int n, ComplexFloat[] a, int lda, int[] sdim, ComplexFloat[] w, ComplexFloat[] vs, int ldvs, float[] rconde, float[] rcondv, ComplexFloat[] work, float[] rwork, bool[] bwork);
		//int Cgeev(char jobvl, char jobvr, int n, ComplexFloat[] a, int lda, ComplexFloat[] w, ComplexFloat[] vl, int ldvl, ComplexFloat[] vr, int ldvr, ComplexFloat[] work, float[] rwork);
		//int Cgeevx(char balanc, char jobvl, char jobvr, char sense, int n, ComplexFloat[] a, int lda, ComplexFloat[] w, ComplexFloat[] vl, int ldvl, ComplexFloat[] vr, int ldvr, int[] ilo, int[] ihi, float[] scale, float[] abnrm, float[] rconde, float[] rcondv, ComplexFloat[] work, float[] rwork);
		//int Cgegs(char jobvsl, char jobvsr, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] alpha, ComplexFloat[] beta, ComplexFloat[] vsl, int ldvsl, ComplexFloat[] vsr, int ldvsr, ComplexFloat[] work, float[] rwork);
		//int Cgegv(char jobvl, char jobvr, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] alpha, ComplexFloat[] beta, ComplexFloat[] vl, int ldvl, ComplexFloat[] vr, int ldvr, ComplexFloat[] work, float[] rwork);
		//int Cgehd2(int n, int[] ilo, int[] ihi, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cgehrd(int n, int[] ilo, int[] ihi, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cgelq2(int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cgelqf(int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cgelsx(int m, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, int[] jpvt, float[] rcond, int[] rank);
		//int Cgelsx(int m, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, int[] jpvt, float[] rcond, int[] rank, ComplexFloat[] work, float[] rwork);
		//int Cgeql2(int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cgeqlf(int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cgeqpf(int m, int n, ComplexFloat[] a, int lda, int[] jpvt, ComplexFloat[] tau, ComplexFloat[] work, float[] rwork, int[] info);
		//int Cgeqr2(int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cgeqrf(int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cgerfs(char trans, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] af, int ldaf, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cgerq2(int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cgerqf(int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cgesc2(int n, ComplexFloat[] a, int lda, ComplexFloat[] rightSide, int[] ipiv, int[] jpiv, float[] scale);
		//int Cgesv(int n, int nrhs, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] b, int ldb);
		//int Cgesvx(char fact, char trans, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] af, int ldaf, int[] ipiv, char equed, float[] r, float[] c, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] rcond, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cgetc2(int n, ComplexFloat[] a, int lda, int[] ipiv, int[] jpiv);
		//int Cgetf2(int m, int n, ComplexFloat[] a, int lda, int[] ipiv);
		//int Cggbak(char job, char side, int n, int[] ilo, int[] ihi, float[] lscale, float[] rscale, int m, ComplexFloat[] v, int ldv);
		//int Cggbal(char job, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, int[] ilo, int[] ihi, float[] lscale, float[] rscale, float[] work);
		//int Cgges(char jobvsl, char jobvsr, char sort, L_fp selctg, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, int[] sdim, ComplexFloat[] alpha, ComplexFloat[] beta, ComplexFloat[] vsl, int ldvsl, ComplexFloat[] vsr, int ldvsr, ComplexFloat[] work, float[] rwork, bool[] bwork);
		//int Cggesx(char jobvsl, char jobvsr, char sort, L_fp selctg, char sense, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, int[] sdim, ComplexFloat[] alpha, ComplexFloat[] beta, ComplexFloat[] vsl, int ldvsl, ComplexFloat[] vsr, int ldvsr, float[] rconde, float[] rcondv, ComplexFloat[] work, float[] rwork, int iwork, int[] liwork, bool[] bwork);
		//int Cggevx(char balanc, char jobvl, char jobvr, char sense, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] alpha, ComplexFloat[] beta, ComplexFloat[] vl, int ldvl, ComplexFloat[] vr, int ldvr, int[] ilo, int[] ihi, float[] lscale, float[] rscale, float[] abnrm, float[] bbnrm, float[] rconde, float[] rcondv, ComplexFloat[] work, float[] rwork, int iwork, bool[] bwork);
		//int Cggglm(int n, int m, int[] p, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] d, ComplexFloat[] x, ComplexFloat[] y, ComplexFloat[] work);
		//int Cgghrd(char compq, char compz, int n, int[] ilo, int[] ihi, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] q, int ldq, ComplexFloat[] z, int ldz);
		//int Cgglse(int m, int n, int[] p, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] c, ComplexFloat[] d, ComplexFloat[] x, ComplexFloat[] work);
		//int Cggqrf(int n, int m, int[] p, ComplexFloat[] a, int lda, ComplexFloat[] taua, ComplexFloat[] b, int ldb, ComplexFloat[] taub, ComplexFloat[] work);
		//int Cggrqf(int m, int[] p, int n, ComplexFloat[] a, int lda, ComplexFloat[] taua, ComplexFloat[] b, int ldb, ComplexFloat[] taub, ComplexFloat[] work);
		//int Cggsvd(char jobu, char jobv, char jobq, int m, int n, int[] p, int k, int[] l, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, float[] alpha, float[] beta, ComplexFloat[] u, int ldu, ComplexFloat[] v, int ldv, ComplexFloat[] q, int ldq, ComplexFloat[] work, float[] rwork, int iwork);
		//int Cggsvp(char jobu, char jobv, char jobq, int m, int[] p, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int[] ldb, float[] tola, float[] tolb, int k, int[] l, ComplexFloat[] u, int ldu, ComplexFloat[] v, int ldv, ComplexFloat[] q, int ldq, int iwork, float[] rwork, ComplexFloat[] tau, ComplexFloat[] work, int[] info);
		//int Cgtcon(char norm, int n, ComplexFloat[] dl, ComplexFloat[] d, ComplexFloat[] du, ComplexFloat[] du2, int[] ipiv, float[] anorm, float[] rcond, ComplexFloat[] work);
		//int Cgtrfs(char trans, int n, int nrhs, ComplexFloat[] dl, ComplexFloat[] d, ComplexFloat[] du, ComplexFloat[] dlf, ComplexFloat[] df, ComplexFloat[] duf, ComplexFloat[] du2, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cgtsv(int n, int nrhs, ComplexFloat[] dl, ComplexFloat[] d, ComplexFloat[] du, ComplexFloat[] b, int ldb);
		//int Cgtsvx(char fact, char trans, int n, int nrhs, ComplexFloat[] dl, ComplexFloat[] d, ComplexFloat[] du, ComplexFloat[] dlf, ComplexFloat[] df, ComplexFloat[] duf, ComplexFloat[] du2, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] rcond, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cgttrf(int n, ComplexFloat[] dl, ComplexFloat[] d, ComplexFloat[] du, ComplexFloat[] du2, int[] ipiv);
		//int Cgttrs(char trans, int n, int nrhs, ComplexFloat[] dl, ComplexFloat[] d, ComplexFloat[] du, ComplexFloat[] du2, int[] ipiv, ComplexFloat[] b, int ldb);
		//int Cgtts2(int[] itrans, int n, int nrhs, ComplexFloat[] dl, ComplexFloat[] d, ComplexFloat[] du, ComplexFloat[] du2, int[] ipiv, ComplexFloat[] b, int ldb);
		//int Chbev(char jobz, char uplo, int n, int[] kd, ComplexFloat[] ab, int ldab, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork);
		//int Chbevd(char jobz, char uplo, int n, int[] kd, ComplexFloat[] ab, int ldab, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Chbevx(char jobz, char range, char uplo, int n, int[] kd, ComplexFloat[] ab, int ldab, ComplexFloat[] q, int ldq, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork, int iwork, int[] ifail);
		//int Chbgst(char vect, char uplo, int n, int[] ka, int[] kb, ComplexFloat[] ab, int ldab, ComplexFloat[] bb, int ldbb, ComplexFloat[] x, int ldx, ComplexFloat[] work, float[] rwork);
		//int Chbgv(char jobz, char uplo, int n, int[] ka, int[] kb, ComplexFloat[] ab, int ldab, ComplexFloat[] bb, int ldbb, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork);
		//int Chbgvx(char jobz, char range, char uplo, int n, int[] ka, int[] kb, ComplexFloat[] ab, int ldab, ComplexFloat[] bb, int ldbb, ComplexFloat[] q, int ldq, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork, int iwork, int[] ifail);
		//int Chbtrd(char vect, char uplo, int n, int[] kd, ComplexFloat[] ab, int ldab, float[] d, float[] e, ComplexFloat[] q, int ldq, ComplexFloat[] work);
		//int Checon(char uplo, int n, ComplexFloat[] a, int lda, int[] ipiv, float[] anorm, float[] rcond, ComplexFloat[] work, int[] info);
		//int Cheev(char jobz, char uplo, int n, ComplexFloat[] a, int lda, float[] w, ComplexFloat[] work, float[] rwork);
		//int Cheevd(char jobz, char uplo, int n, ComplexFloat[] a, int lda, float[] w, ComplexFloat[] work, float[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Cheevr(char jobz, char range, char uplo, int n, ComplexFloat[] a, int lda, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, ComplexFloat[] z, int ldz, int[] isuppz, ComplexFloat[] work, float[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Cheevx(char jobz, char range, char uplo, int n, ComplexFloat[] a, int lda, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork, int iwork, int[] ifail);
		//int Chegs2(int[] itype, char uplo, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb);
		//int Chegst(int[] itype, char uplo, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb);
		//int Chegv(int[] itype, char jobz, char uplo, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, float[] w, ComplexFloat[] work, float[] rwork);
		//int Chegvd(int[] itype, char jobz, char uplo, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, float[] w, ComplexFloat[] work, float[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Chegvx(int[] itype, char jobz, char range, char uplo, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork, int iwork, int[] ifail);
		//int Cherfs(char uplo, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] af, int ldaf, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Chesv(char uplo, int n, int nrhs, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] work);
		//int Chesvx(char fact, char uplo, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] af, int ldaf, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] rcond, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Chetf2(char uplo, int n, ComplexFloat[] a, int lda, int[] ipiv);
		//int Chetrd(char uplo, int n, ComplexFloat[] a, int lda, float[] d, float[] e, ComplexFloat[] tau, ComplexFloat[] work);
		//int Chetrf(char uplo, int n, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] work);
		//int Chetri(char uplo, int n, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] work);
		//int Chetrs(char uplo, int n, int nrhs, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] b, int ldb, int[] info);
		//int Chgeqz(char job, char compq, char compz, int n, int[] ilo, int[] ihi, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] alpha, ComplexFloat[] beta, ComplexFloat[] q, int ldq, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork);
		//int Chpcon(char uplo, int n, ComplexFloat[] ap, int[] ipiv, float[] anorm, float[] rcond, ComplexFloat[] work);
		//int Chpev(char jobz, char uplo, int n, ComplexFloat[] ap, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork);
		//int Chpevd(char jobz, char uplo, int n, ComplexFloat[] ap, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Chpevx(char jobz, char range, char uplo, int n, ComplexFloat[] ap, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork, int iwork, int[] ifail);
		//int Chpgst(int[] itype, char uplo, int n, ComplexFloat[] ap, ComplexFloat[] bp);
		//int Chpgv(int[] itype, char jobz, char uplo, int n, ComplexFloat[] ap, ComplexFloat[] bp, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork);
		//int Chpgvd(int[] itype, char jobz, char uplo, int n, ComplexFloat[] ap, ComplexFloat[] bp, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Chpgvx(int[] itype, char jobz, char range, char uplo, int n, ComplexFloat[] ap, ComplexFloat[] bp, float[] vl, float[] vu, int[] il, int[] iu, float[] abstol, int m, float[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork, int iwork, int[] ifail);
		//int Chprfs(char uplo, int n, int nrhs, ComplexFloat[] ap, ComplexFloat[] afp, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Chpsv(char uplo, int n, int nrhs, ComplexFloat[] ap, int[] ipiv, ComplexFloat[] b, int ldb);
		//int Chpsvx(char fact, char uplo, int n, int nrhs, ComplexFloat[] ap, ComplexFloat[] afp, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] rcond, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Chptrd(char uplo, int n, ComplexFloat[] ap, float[] d, float[] e, ComplexFloat[] tau);
		//int Chptrf(char uplo, int n, ComplexFloat[] ap, int[] ipiv);
		//int Chptri(char uplo, int n, ComplexFloat[] ap, int[] ipiv, ComplexFloat[] work);
		//int Chptrs(char uplo, int n, int nrhs, ComplexFloat[] ap, int[] ipiv, ComplexFloat[] b, int ldb);
		//int Chsein(char side, char eigsrc, char initv, bool[] select, int n, ComplexFloat[] h, int ldh, ComplexFloat[] w, ComplexFloat[] vl, int ldvl, ComplexFloat[] vr, int ldvr, int[] mm, int m, ComplexFloat[] work, float[] rwork, int[] ifaill, int[] ifailr);
		//int Chseqr(char job, char compz, int n, int[] ilo, int[] ihi, ComplexFloat[] h, int ldh, ComplexFloat[] w, ComplexFloat[] z, int ldz, ComplexFloat[] work);
		//int Clabrd(int m, int n, int[] nb, ComplexFloat[] a, int lda, float[] d, float[] e, ComplexFloat[] tauq, ComplexFloat[] taup, ComplexFloat[] x, int ldx, ComplexFloat[] y, int ldy);
		//int Clacgv(int n, ComplexFloat[] x, int[] incx);
		//int Clacon(int n, ComplexFloat[] v, ComplexFloat[] x, float[] est, int[] kase);
		//int Clacp2(char uplo, int m, int n, float[] a, int lda, ComplexFloat[] b, int ldb);
		//int Clacpy(char uplo, int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb);
		//int Clacrm(int m, int n, ComplexFloat[] a, int lda, float[] b, int ldb, ComplexFloat[] c, int ldc, float[] rwork);
		//int Clacrt(int n, ComplexFloat[] cx, int[] incx, ComplexFloat[] cy, int[] incy, ComplexFloat[] c, ComplexFloat[] s);
		//int Claed0(int[] qsiz, int n, float[] d, float[] e, ComplexFloat[] q, int ldq, ComplexFloat[] qstore, int ldqs, float[] rwork, int iwork);
		//int Claed7(int n, int[] cutpnt, int[] qsiz, int[] tlvls, int[] curlvl, int[] curpbm, float[] d, ComplexFloat[] q, int ldq, float[] rho, int[] indxq, float[] qstore, int[] qptr, int[] prmptr, int[] perm, int[] givptr, int[] givcol, float[] givnum, ComplexFloat[] work, float[] rwork, int iwork);
		//int Claed8(int k, int n, int[] qsiz, ComplexFloat[] q, int ldq, float[] d, float[] rho, int[] cutpnt, float[] z, float[] dlamda, ComplexFloat[] q2, int ldq2, float[] w, int[] indxp, int[] indx, int[] indxq, int[] perm, int[] givptr, int[] givcol, float[] givnum);
		//int Claein(bool[] rightv, bool[] noinit, int n, ComplexFloat[] h, int ldh, ComplexFloat[] w, ComplexFloat[] v, ComplexFloat[] b, int ldb, float[] rwork, float[] eps3, float[] smlnum);
		//int Claesy(ComplexFloat[] a, ComplexFloat[] b, ComplexFloat[] c, ComplexFloat[] rt1, ComplexFloat[] rt2, ComplexFloat[] evscal, ComplexFloat[] cs1, ComplexFloat[] sn1);
		//int Claev2(ComplexFloat[] a, ComplexFloat[] b, ComplexFloat[] c, float[] rt1, float[] rt2, float[] cs1, ComplexFloat[] sn1);
		//int Clags2(bool[] upper, float[] a1, ComplexFloat[] a2, float[] a3, float[] b1, ComplexFloat[] b2, float[] b3, float[] csu, ComplexFloat[] snu, float[] csv, ComplexFloat[] snv, float[] csq, ComplexFloat[] snq);
		//int Clagtm(char trans, int n, int nrhs, float[] alpha, ComplexFloat[] dl, ComplexFloat[] d, ComplexFloat[] du, ComplexFloat[] x, int ldx, float[] beta, ComplexFloat[] b, int ldb);
		//int Clahef(char uplo, int n, int[] nb, int[] kb, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] w, int ldw);
		//int Clahqr(bool[] wantt, bool[] wantz, int n, int[] ilo, int[] ihi, ComplexFloat[] h, int ldh, ComplexFloat[] w, int[] iloz, int[] ihiz, ComplexFloat[] z, int ldz, int[] info);
		//int Clahrd(int n, int k, int[] nb, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] t, int ldt, ComplexFloat[] y, int ldy);
		//int Claic1(int[] job, int[] j, ComplexFloat[] x, float[] sest, ComplexFloat[] w, ComplexFloat[] gamma, float[] sestpr, ComplexFloat[] s, ComplexFloat[] c);
		//int Clals0(int[] icompq, int[] nl, int[] nr, int[] sqre, int nrhs, ComplexFloat[] b, int ldb, ComplexFloat[] bx, int ldbx, int[] perm, int[] givptr, int[] givcol, int ldgcol, float[] givnum, int ldgnum, float[] poles, float[] difl, float[] difr, float[] z, int k, float[] c, float[] s, float[] rwork);
		//int Clalsa(int[] icompq, int[] smlsiz, int n, int nrhs, ComplexFloat[] b, int ldb, ComplexFloat[] bx, int ldbx, float[] u, int ldu, float[] vt, int k, float[] difl, float[] difr, float[] z, float[] poles, int[] givptr, int[] givcol, int ldgcol, int[] perm, float[] givnum, float[] c, float[] s, float[] rwork, int iwork);
		//int Clapll(int n, ComplexFloat[] x, int[] incx, ComplexFloat[] y, int[] incy, float[] ssmin);
		//int Clapmt(bool[] forwrd, int m, int n, ComplexFloat[] x, int ldx, int k);
		//int Claqgb(int m, int n, int kl, int ku, ComplexFloat[] ab, int ldab, float[] r, float[] c, float[] rowcnd, float[] colcnd, float[] amax, char equed);
		//int Claqge(int m, int n, ComplexFloat[] a, int lda, float[] r, float[] c, float[] rowcnd, float[] colcnd, float[] amax, char equed);
		//int Claqhb(char uplo, int n, int[] kd, ComplexFloat[] ab, int ldab, float[] s, float[] scond, float[] amax, char equed);
		//int Claqhe(char uplo, int n, ComplexFloat[] a, int lda, float[] s, float[] scond, float[] amax, char equed);
		//int Claqhp(char uplo, int n, ComplexFloat[] ap, float[] s, float[] scond, float[] amax, char equed);
		//int Claqp2(int m, int n, int[] offset, ComplexFloat[] a, int lda, int[] jpvt, ComplexFloat[] tau, float[] vn1, float[] vn2, ComplexFloat[] work);
		//int Claqps(int m, int n, int[] offset, int[] nb, int[] kb, ComplexFloat[] a, int lda, int[] jpvt, ComplexFloat[] tau, float[] vn1, float[] vn2, ComplexFloat[] auxv, ComplexFloat[] f, int ldf);
		//int Claqsb(char uplo, int n, int[] kd, ComplexFloat[] ab, int ldab, float[] s, float[] scond, float[] amax, char equed);
		//int Claqsp(char uplo, int n, ComplexFloat[] ap, float[] s, float[] scond, float[] amax, char equed);
		//int Claqsy(char uplo, int n, ComplexFloat[] a, int lda, float[] s, float[] scond, float[] amax, char equed);
		//int Clar1v(int n, int[] b1, int[] bn, float[] sigma, float[] d, float[] l, float[] ld, float[] lld, float[] gersch, ComplexFloat[] z, float[] ztz, float[] mingma, int[] r, int[] isuppz, float[] work);
		//int Clar2v(int n, ComplexFloat[] x, ComplexFloat[] y, ComplexFloat[] z, int[] incx, float[] c, ComplexFloat[] s, int[] incc);
		//int Clarcm(int m, int n, float[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] c, int ldc, float[] rwork);
		//int Clarf(char side, int m, int n, ComplexFloat[] v, int[] incv, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Clarfb(char side, char trans, char direct, char storev, int m, int n, int k, ComplexFloat[] v, int ldv, ComplexFloat[] t, int ldt, ComplexFloat[] c, int ldc, ComplexFloat[] work, int ldwork);
		//int Clarfg(int n, ComplexFloat[] alpha, ComplexFloat[] x, int[] incx, ComplexFloat[] tau);
		//int Clarft(char direct, char storev, int n, int k, ComplexFloat[] v, int ldv, ComplexFloat[] tau, ComplexFloat[] t, int ldt);
		//int Clarfx(char side, int m, int n, ComplexFloat[] v, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Clargv(int n, ComplexFloat[] x, int[] incx, ComplexFloat[] y, int[] incy, float[] c, int[] incc);
		//int Clarnv(int[] idist, int[] iseed, int n, ComplexFloat[] x);
		//int Clarrv(int n, float[] d, float[] l, int[] isplit, int m, float[] w, int[] iblock, float[] gersch, float[] tol, ComplexFloat[] z, int ldz, int[] isuppz, float[] work, int iwork);
		//int Clartg(ComplexFloat[] f, ComplexFloat[] g, float[] cs, ComplexFloat[] sn, ComplexFloat[] r);
		//int Clartv(int n, ComplexFloat[] x, int[] incx, ComplexFloat[] y, int[] incy, float[] c, ComplexFloat[] s, int[] incc);
		//int Clarz(char side, int m, int n, int[] l, ComplexFloat[] v, int[] incv, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Clarzb(char side, char trans, char direct, char storev, int m, int n, int k, int[] l, ComplexFloat[] v, int ldv, ComplexFloat[] t, int ldt, ComplexFloat[] c, int ldc, ComplexFloat[] work, int ldwork);
		//int Clarzt(char direct, char storev, int n, int k, ComplexFloat[] v, int ldv, ComplexFloat[] tau, ComplexFloat[] t, int ldt);
		//int Clascl(char type, int kl, int ku, float[] cfrom, float[] cto, int m, int n, ComplexFloat[] a, int lda);
		//int Claset(char uplo, int m, int n, ComplexFloat[] alpha, ComplexFloat[] beta, ComplexFloat[] a, int lda);
		//int Clasr(char side, char pivot, char direct, int m, int n, float[] c, float[] s, ComplexFloat[] a, int lda);
		//int Classq(int n, ComplexFloat[] x, int[] incx, float[] scale, float[] sumsq);
		//int Claswp(int n, ComplexFloat[] a, int lda, int[] k1, int[] k2, int[] ipiv, int[] incx);
		//int Clasyf(char uplo, int n, int[] nb, int[] kb, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] w, int ldw);
		//int Clatbs(char uplo, char trans, char diag, char normin, int n, int[] kd, ComplexFloat[] ab, int ldab, ComplexFloat[] x, float[] scale, float[] cnorm);
		//int Clatdf(int[] ijob, int n, ComplexFloat[] z, int[] ldz, ComplexFloat[] rightSide, float[] rdsum, float[] rdscal, int[] ipiv, int[] jpiv);
		//int Clatps(char uplo, char trans, char diag, char normin, int n, ComplexFloat[] ap, ComplexFloat[] x, float[] scale, float[] cnorm);
		//int Clatrd(char uplo, int n, int[] nb, ComplexFloat[] a, int lda, float[] e, ComplexFloat[] tau, ComplexFloat[] w, int ldw);
		//int Clatrs(char uplo, char trans, char diag, char normin, int n, ComplexFloat[] a, int lda, ComplexFloat[] x, float[] scale, float[] cnorm);
		//int Clatrz(int m, int n, int[] l, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Clatzm(char side, int m, int n, ComplexFloat[] v, int[] incv, ComplexFloat[] tau, ComplexFloat[] c1, ComplexFloat[] c2, int ldc, ComplexFloat[] work);
		//int Clauu2(char uplo, int n, ComplexFloat[] a, int lda);
		//int Clauum(char uplo, int n, ComplexFloat[] a, int lda);
		//int Cpbcon(char uplo, int n, int[] kd, ComplexFloat[] ab, int ldab, float[] anorm, float[] rcond, ComplexFloat[] work, float[] rwork);
		//int Cpbequ(char uplo, int n, int[] kd, ComplexFloat[] ab, int ldab, float[] s, float[] scond, float[] amax);
		//int Cpbrfs(char uplo, int n, int[] kd, int nrhs, ComplexFloat[] ab, int ldab, ComplexFloat[] afb, int ldafb, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cpbstf(char uplo, int n, int[] kd, ComplexFloat[] ab, int ldab);
		//int Cpbsv(char uplo, int n, int[] kd, int nrhs, ComplexFloat[] ab, int ldab, ComplexFloat[] b, int ldb, int[] info);
		//int Cpbsvx(char fact, char uplo, int n, int[] kd, int nrhs, ComplexFloat[] ab, int ldab, ComplexFloat[] afb, int ldafb, char equed, float[] s, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] rcond, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cpbtf2(char uplo, int n, int[] kd, ComplexFloat[] ab, int ldab);
		//int Cpbtrf(char uplo, int n, int[] kd, ComplexFloat[] ab, int ldab);
		//int Cpbtrs(char uplo, int n, int[] kd, int nrhs, ComplexFloat[] ab, int ldab, ComplexFloat[] b, int ldb, int[] info);
		//int Cpocon(char uplo, int n, ComplexFloat[] a, int lda, float[] anorm, float[] rcond, ComplexFloat[] work, float[] rwork);
		//int Cpoequ(int n, ComplexFloat[] a, int lda, float[] s, float[] scond, float[] amax);
		//int Cporfs(char uplo, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] af, int ldaf, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cposv(char uplo, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb);
		//int Cposvx(char fact, char uplo, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] af, int ldaf, char equed, float[] s, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] rcond, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cpotf2(char uplo, int n, ComplexFloat[] a, int lda);
		//int Cppcon(char uplo, int n, ComplexFloat[] ap, float[] anorm, float[] rcond, ComplexFloat[] work, float[] rwork);
		//int Cppequ(char uplo, int n, ComplexFloat[] ap, float[] s, float[] scond, float[] amax);
		//int Cpprfs(char uplo, int n, int nrhs, ComplexFloat[] ap, ComplexFloat[] afp, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cppsv(char uplo, int n, int nrhs, ComplexFloat[] ap, ComplexFloat[] b, int ldb);
		//int Cppsvx(char fact, char uplo, int n, int nrhs, ComplexFloat[] ap, ComplexFloat[] afp, char equed, float[] s, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] rcond, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cpptrf(char uplo, int n, ComplexFloat[] ap, int[] info);
		//int Cpptri(char uplo, int n, ComplexFloat[] ap, int[] info);
		//int Cpptrs(char uplo, int n, int nrhs, ComplexFloat[] ap, ComplexFloat[] b, int ldb);
		//int Cptcon(int n, float[] d, ComplexFloat[] e, float[] anorm, float[] rcond, float[] rwork);
		//int Cptrfs(char uplo, int n, int nrhs, float[] d, ComplexFloat[] e, float[] df, ComplexFloat[] ef, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cptsv(int n, int nrhs, float[] d, ComplexFloat[] e, ComplexFloat[] b, int ldb);
		//int Cptsvx(char fact, int n, int nrhs, float[] d, ComplexFloat[] e, float[] df, ComplexFloat[] ef, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] rcond, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cpttrf(int n, float[] d, ComplexFloat[] e);
		//int Cpttrs(char uplo, int n, int nrhs, float[] d, ComplexFloat[] e, ComplexFloat[] b, int ldb);
		//int Cptts2(int[] iuplo, int n, int nrhs, float[] d, ComplexFloat[] e, ComplexFloat[] b, int ldb);
		//int Crot(int n, ComplexFloat[] cx, int[] incx, ComplexFloat[] cy, int[] incy, float[] c, ComplexFloat[] s);
		//int Cspcon(char uplo, int n, ComplexFloat[] ap, int[] ipiv, float[] anorm, float[] rcond, ComplexFloat[] work);
		//int Cspmv(char uplo, int n, ComplexFloat[] alpha, ComplexFloat[] ap, ComplexFloat[] x, int[] incx, ComplexFloat[] beta, ComplexFloat[] y, int[] incy);
		//int Cspr(char uplo, int n, ComplexFloat[] alpha, ComplexFloat[] x, int[] incx, ComplexFloat[] ap);
		//int Csprfs(char uplo, int n, int nrhs, ComplexFloat[] ap, ComplexFloat[] afp, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Cspsv(char uplo, int n, int nrhs, ComplexFloat[] ap, int[] ipiv, ComplexFloat[] b, int ldb);
		//int Cspsvx(char fact, char uplo, int n, int nrhs, ComplexFloat[] ap, ComplexFloat[] afp, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] rcond, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Csptrf(char uplo, int n, ComplexFloat[] ap, int[] ipiv);
		//int Csptri(char uplo, int n, ComplexFloat[] ap, int[] ipiv, ComplexFloat[] work);
		//int Csptrs(char uplo, int n, int nrhs, ComplexFloat[] ap, int[] ipiv, ComplexFloat[] b, int ldb);
		//int Csrot(int n, ComplexFloat[] cx, int[] incx, ComplexFloat[] cy, int[] incy, float[] c, float[] s);
		//int Csrscl(int n, float[] sa, ComplexFloat[] sx, int[] incx);
		//int Cstedc(char compz, int n, float[] d, float[] e, ComplexFloat[] z, int ldz, ComplexFloat[] work, float[] rwork, int[] lrwork, int iwork, int[] liwork, int[] info);
		//int Cstein(int n, float[] d, float[] e, int m, float[] w, int[] iblock, int[] isplit, ComplexFloat[] z, int ldz, float[] work, int iwork, int[] ifail);
		//int Csteqr(char compz, int n, float[] d, float[] e, ComplexFloat[] z, int ldz, float[] work);
		//int Csycon(char uplo, int n, ComplexFloat[] a, int lda, int[] ipiv, float[] anorm, float[] rcond, ComplexFloat[] work, int[] info);
		//int Csymv(char uplo, int n, ComplexFloat[] alpha, ComplexFloat[] a, int lda, ComplexFloat[] x, int[] incx, ComplexFloat[] beta, ComplexFloat[] y, int[] incy);
		//int Csyr(char uplo, int n, ComplexFloat[] alpha, ComplexFloat[] x, int[] incx, ComplexFloat[] a, int lda);
		//int Csyrfs(char uplo, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] af, int ldaf, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Csysv(char uplo, int n, int nrhs, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] work);
		//int Csysvx(char fact, char uplo, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] af, int ldaf, int[] ipiv, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] rcond, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Csytf2(char uplo, int n, ComplexFloat[] a, int lda, int[] ipiv);
		//int Csytrf(char uplo, int n, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] work);
		//int Csytri(char uplo, int n, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] work);
		//int Csytrs(char uplo, int n, int nrhs, ComplexFloat[] a, int lda, int[] ipiv, ComplexFloat[] b, int ldb, int[] info);
		//int Ctbcon(char norm, char uplo, char diag, int n, int[] kd, ComplexFloat[] ab, int ldab, float[] rcond, ComplexFloat[] work, float[] rwork);
		//int Ctbrfs(char uplo, char trans, char diag, int n, int[] kd, int nrhs, ComplexFloat[] ab, int ldab, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Ctbtrs(char uplo, char trans, char diag, int n, int[] kd, int nrhs, ComplexFloat[] ab, int ldab, ComplexFloat[] b, int ldb);
		//int Ctgevc(char side, char howmny, bool[] select, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] vl, int ldvl, ComplexFloat[] vr, int ldvr, int[] mm, int m, ComplexFloat[] work, float[] rwork);
		//int Ctgex2(bool[] wantq, bool[] wantz, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] q, int ldq, ComplexFloat[] z, int ldz, int[] j1);
		//int Ctgexc(bool[] wantq, bool[] wantz, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] q, int ldq, ComplexFloat[] z, int ldz, int[] ifst, int[] ilst);
		//int Ctgsen(int[] ijob, bool[] wantq, bool[] wantz, bool[] select, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] alpha, ComplexFloat[] beta, ComplexFloat[] q, int ldq, ComplexFloat[] z, int ldz, int m, float[] pl, float[] pr, float[] dif, ComplexFloat[] work, int iwork, int[] liwork);
		//int Ctgsja(char jobu, char jobv, char jobq, int m, int[] p, int n, int k, int[] l, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, float[] tola, float[] tolb, float[] alpha, float[] beta, ComplexFloat[] u, int ldu, ComplexFloat[] v, int ldv, ComplexFloat[] q, int ldq, ComplexFloat[] work, int[] ncycle, int[] info);
		//int Ctgsna(char job, char howmny, bool[] select, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] vl, int ldvl, ComplexFloat[] vr, int ldvr, float[] s, float[] dif, int[] mm, int m, ComplexFloat[] work, int iwork);
		//int Ctgsy2(char trans, int[] ijob, int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] c, int ldc, ComplexFloat[] d, int ldd, ComplexFloat[] e, int lde, ComplexFloat[] f, int ldf, float[] scale, float[] rdsum, float[] rdscal);
		//int Ctgsyl(char trans, int[] ijob, int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] c, int ldc, ComplexFloat[] d, int ldd, ComplexFloat[] e, int lde, ComplexFloat[] f, int ldf, float[] scale, float[] dif, ComplexFloat[] work, int iwork);
		//int Ctpcon(char norm, char uplo, char diag, int n, ComplexFloat[] ap, float[] rcond, ComplexFloat[] work, float[] rwork);
		//int Ctprfs(char uplo, char trans, char diag, int n, int nrhs, ComplexFloat[] ap, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Ctptri(char uplo, char diag, int n, ComplexFloat[] ap);
		//int Ctptrs(char uplo, char trans, char diag, int n, int nrhs, ComplexFloat[] ap, ComplexFloat[] b, int ldb);
		//int Ctrcon(char norm, char uplo, char diag, int n, ComplexFloat[] a, int lda, float[] rcond, ComplexFloat[] work, float[] rwork);
		//int Ctrevc(char side, char howmny, bool[] select, int n, ComplexFloat[] t, int ldt, ComplexFloat[] vl, int ldvl, ComplexFloat[] vr, int ldvr, int[] mm, int m, ComplexFloat[] work, float[] rwork);
		//int Ctrexc(char compq, int n, ComplexFloat[] t, int ldt, ComplexFloat[] q, int ldq, int[] ifst, int[] ilst, int[] info);
		//int Ctrrfs(char uplo, char trans, char diag, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] x, int ldx, float[] ferr, float[] berr, ComplexFloat[] work, float[] rwork);
		//int Ctrsen(char job, char compq, bool[] select, int n, ComplexFloat[] t, int ldt, ComplexFloat[] q, int ldq, ComplexFloat[] w, int m, float[] s, float[] sep, ComplexFloat[] work);
		//int Ctrsna(char job, char howmny, bool[] select, int n, ComplexFloat[] t, int ldt, ComplexFloat[] vl, int ldvl, ComplexFloat[] vr, int ldvr, float[] s, float[] sep, int[] mm, int m, ComplexFloat[] work, int ldwork, float[] rwork);
		//int Ctrsyl(char trana, char tranb, int[] isgn, int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat[] c, int ldc, float[] scale);
		//int Ctrti2(char uplo, char diag, int n, ComplexFloat[] a, int lda);
		//int Ctrtri(char uplo, char diag, int n, ComplexFloat[] a, int lda);
		//int Ctrtrs(char uplo, char trans, char diag, int n, int nrhs, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb);
		//int Ctzrqf(int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau);
		//int Ctzrzf(int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cung2l(int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cung2r(int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cungbr(char vect, int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cunghr(int n, int[] ilo, int[] ihi, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cungl2(int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cunglq(int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work, int[] info);
		//int Cungql(int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work, int[] info);
		//int Cungr2(int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cungrq(int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work, int[] info);
		//int Cungtr(char uplo, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] work);
		//int Cunm2l(char side, char trans, int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Cunm2r(char side, char trans, int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Cunmbr(char vect, char side, char trans, int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work, int[] info);
		//int Cunmhr(char side, char trans, int m, int n, int[] ilo, int[] ihi, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work, int[] info);
		//int Cunml2(char side, char trans, int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Cunmlq(char side, char trans, int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Cunmql(char side, char trans, int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Cunmr2(char side, char trans, int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Cunmr3(char side, char trans, int m, int n, int k, int[] l, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Cunmrq(char side, char trans, int m, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Cunmrz(char side, char trans, int m, int n, int k, int[] l, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work, int[] info);
		//int Cunmtr(char side, char uplo, char trans, int m, int n, ComplexFloat[] a, int lda, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Cupgtr(char uplo, int n, ComplexFloat[] ap, ComplexFloat[] tau, ComplexFloat[] q, int ldq, ComplexFloat[] work);
		//int Cupmtr(char side, char uplo, char trans, int m, int n, ComplexFloat[] ap, ComplexFloat[] tau, ComplexFloat[] c, int ldc, ComplexFloat[] work);
		//int Zdrot(int n, ComplexDouble[] cx, int[] incx, ComplexDouble[] cy, int[] incy, double[] c, double[] s);
		//int Zdrscl(int n, double[] sa, ComplexDouble[] sx, int[] incx);
		//int Zgbcon(char norm, int n, int kl, int ku, ComplexDouble[] ab, int ldab, int[] ipiv, double[] anorm, double[] rcond, ComplexDouble[] work, double[] rwork, int[] info);
		//int Zgbequ(int m, int n, int kl, int ku, ComplexDouble[] ab, int ldab, double[] r, double[] c, double[] rowcnd, double[] colcnd, double[] amax, int[] info);
		//int Zgbrfs(char trans, int n, int kl, int ku, int nrhs, ComplexDouble[] ab, int ldab, ComplexDouble[] afb, int ldafb, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zgbsv(int n, int kl, int ku, int nrhs, ComplexDouble[] ab, int ldab, int[] ipiv, ComplexDouble[] b, int ldb);
		//int Zgbsvx(char fact, char trans, int n, int kl, int ku, int nrhs, ComplexDouble[] ab, int ldab, ComplexDouble[] afb, int ldafb, int[] ipiv, char equed, double[] r, double[] c, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] rcond, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork, int[] info);
		//int Zgbtf2(int m, int n, int kl, int ku, ComplexDouble[] ab, int ldab, int[] ipiv);
		//int Zgbtrf(int m, int n, int kl, int ku, ComplexDouble[] ab, int ldab, int[] ipiv);
		//int Zgbtrs(char trans, int n, int kl, int ku, int nrhs, ComplexDouble[] ab, int ldab, int[] ipiv, ComplexDouble[] b, int ldb);
		//int Zgebak(char job, char side, int n, int[] ilo, int[] ihi, double[] scale, int m, ComplexDouble[] v, int ldv);
		//int Zgebal(char job, int n, ComplexDouble[] a, int[] lda, int[] ilo, int[] ihi, double[] scale);
		//int Zgebd2(int m, int n, ComplexDouble[] a, int lda, double[] d, double[] e, ComplexDouble[] tauq, ComplexDouble[] taup, ComplexDouble[] work);
		//int Zgeequ(int m, int n, ComplexDouble[] a, int lda, double[] r, double[] c, double[] rowcnd, double[] colcnd, double[] amax);
		//int Zgees(char jobvs, char sort, L_fp select, int n, ComplexDouble[] a, int lda, int[] sdim, ComplexDouble[] w, ComplexDouble[] vs, int ldvs, ComplexDouble[] work, double[] rwork, bool[] bwork);
		//int Zgeesx(char jobvs, char sort, L_fp select, char sense, int n, ComplexDouble[] a, int lda, int[] sdim, ComplexDouble[] w, ComplexDouble[] vs, int ldvs, double[] rconde, double[] rcondv, ComplexDouble[] work, double[] rwork, bool[] bwork);
		//int Zgeev(char jobvl, char jobvr, int n, ComplexDouble[] a, int lda, ComplexDouble[] w, ComplexDouble[] vl, int ldvl, ComplexDouble[] vr, int ldvr, ComplexDouble[] work, double[] rwork);
		//int Zgeevx(char balanc, char jobvl, char jobvr, char sense, int n, ComplexDouble[] a, int lda, ComplexDouble[] w, ComplexDouble[] vl, int ldvl, ComplexDouble[] vr, int ldvr, int[] ilo, int[] ihi, double[] scale, double[] abnrm, double[] rconde, double[] rcondv, ComplexDouble[] work, double[] rwork);
		//int Zgegs(char jobvsl, char jobvsr, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] alpha, ComplexDouble[] beta, ComplexDouble[] vsl, int ldvsl, ComplexDouble[] vsr, int ldvsr, ComplexDouble[] work, double[] rwork);
		//int Zgegv(char jobvl, char jobvr, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] alpha, ComplexDouble[] beta, ComplexDouble[] vl, int[] ldvl, ComplexDouble[] vr, int ldvr, ComplexDouble[] work, double[] rwork);
		//int Zgehd2(int n, int[] ilo, int[] ihi, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zgehrd(int n, int[] ilo, int[] ihi, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zgelq2(int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zgelqf(int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zgelsx(int m, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, int[] jpvt, double[] rcond, int[] rank);
		//int Zgelsx(int m, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, int[] jpvt, double[] rcond, int[] rank, ComplexDouble[] work, double[] rwork);
		//int Zgeql2(int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zgeqlf(int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zgeqpf(int m, int n, ComplexDouble[] a, int lda, int[] jpvt, ComplexDouble[] tau, ComplexDouble[] work, double[] rwork);
		//int Zgeqr2(int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zgeqrf(int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zgerfs(char trans, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] af, int ldaf, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zgerq2(int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zgerqf(int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zgesc2(int n, ComplexDouble[] a, int lda, ComplexDouble[] rightSide, int[] ipiv, int[] jpiv, double[] scale);
		//int Zgesv(int n, int nrhs, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] b, int ldb, int[] info);
		//int Zgesvx(char fact, char trans, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] af, int ldaf, int[] ipiv, char equed, double[] r, double[] c, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] rcond, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zgetc2(int n, ComplexDouble[] a, int lda, int[] ipiv, int[] jpiv);
		//int Zgetf2(int m, int n, ComplexDouble[] a, int lda, int[] ipiv);
		//int Zggbak(char job, char side, int n, int[] ilo, int[] ihi, double[] lscale, double[] rscale, int m, ComplexDouble[] v, int ldv);
		//int Zggbal(char job, int n, ComplexDouble[] a, int[] lda, ComplexDouble[] b, int ldb, int[] ilo, int[] ihi, double[] lscale, double[] rscale, double[] work, int[] info);
		//int Zgges(char jobvsl, char jobvsr, char sort, L_fp delctg, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, int[] sdim, ComplexDouble[] alpha, ComplexDouble[] beta, ComplexDouble[] vsl, int ldvsl, ComplexDouble[] vsr, int[] ldvsr, ComplexDouble[] work, double[] rwork, bool[] bwork);
		//int Zggesx(char jobvsl, char jobvsr, char sort, L_fp delctg, char sense, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, int[] sdim, ComplexDouble[] alpha, ComplexDouble[] beta, ComplexDouble[] vsl, int ldvsl, ComplexDouble[] vsr, int ldvsr, double[] rconde, double[] rcondv, ComplexDouble[] work, double[] rwork, int iwork, int[] liwork, bool[] bwork);
		//int Zggevx(char balanc, char jobvl, char jobvr, char sense, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] alpha, ComplexDouble[] beta, ComplexDouble[] vl, int ldvl, ComplexDouble[] vr, int ldvr, int[] ilo, int[] ihi, double[] lscale, double[] rscale, double[] abnrm, double[] bbnrm, double[] rconde, double[] rcondv, ComplexDouble[] work, double[] rwork, int iwork, bool[] bwork);
		//int Zggglm(int n, int m, int[] p, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] d, ComplexDouble[] x, ComplexDouble[] y, ComplexDouble[] work);
		//int Zgghrd(char compq, char compz, int n, int[] ilo, int[] ihi, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] q, int ldq, ComplexDouble[] z, int ldz);
		//int Zgglse(int m, int n, int[] p, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] c, ComplexDouble[] d, ComplexDouble[] x, ComplexDouble[] work);
		//int Zggqrf(int n, int m, int[] p, ComplexDouble[] a, int lda, ComplexDouble[] taua, ComplexDouble[] b, int ldb, ComplexDouble[] taub, ComplexDouble[] work);
		//int Zggrqf(int m, int[] p, int n, ComplexDouble[] a, int lda, ComplexDouble[] taua, ComplexDouble[] b, int ldb, ComplexDouble[] taub, ComplexDouble[] work);
		//int Zggsvd(char jobu, char jobv, char jobq, int m, int n, int[] p, int k, int[] l, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, double[] alpha, double[] beta, ComplexDouble[] u, int ldu, ComplexDouble[] v, int ldv, ComplexDouble[] q, int ldq, ComplexDouble[] work, double[] rwork, int iwork);
		//int Zggsvp(char jobu, char jobv, char jobq, int m, int[] p, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, double[] tola, double[] tolb, int k, int[] l, ComplexDouble[] u, int ldu, ComplexDouble[] v, int[] ldv, ComplexDouble[] q, int ldq, int iwork, double[] rwork, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zgtcon(char norm, int n, ComplexDouble[] dl, ComplexDouble[] d, ComplexDouble[] du, ComplexDouble[] du2, int[] ipiv, double[] anorm, double[] rcond, ComplexDouble[] work);
		//int Zgtrfs(char trans, int n, int nrhs, ComplexDouble[] dl, ComplexDouble[] d, ComplexDouble[] du, ComplexDouble[] dlf, ComplexDouble[] df, ComplexDouble[] duf, ComplexDouble[] du2, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zgtsv(int n, int nrhs, ComplexDouble[] dl, ComplexDouble[] d, ComplexDouble[] du, ComplexDouble[] b, int ldb);
		//int Zgtsvx(char fact, char trans, int n, int nrhs, ComplexDouble[] dl, ComplexDouble[] d, ComplexDouble[] du, ComplexDouble[] dlf, ComplexDouble[] df, ComplexDouble[] duf, ComplexDouble[] du2, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] rcond, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork, int[] info);
		//int Zgttrf(int n, ComplexDouble[] dl, ComplexDouble[] d, ComplexDouble[] du, ComplexDouble[] du2, int[] ipiv, int[] info);
		//int Zgttrs(char trans, int n, int nrhs, ComplexDouble[] dl, ComplexDouble[] d, ComplexDouble[] du, ComplexDouble[] du2, int[] ipiv, ComplexDouble[] b, int ldb);
		//int Zgtts2(int[] itrans, int n, int nrhs, ComplexDouble[] dl, ComplexDouble[] d, ComplexDouble[] du, ComplexDouble[] du2, int[] ipiv, ComplexDouble[] b, int ldb);
		//int Zhbev(char jobz, char uplo, int n, int[] kd, ComplexDouble[] ab, int ldab, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork);
		//int Zhbevd(char jobz, char uplo, int n, int[] kd, ComplexDouble[] ab, int ldab, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Zhbevx(char jobz, char range, char uplo, int n, int[] kd, ComplexDouble[] ab, int ldab, ComplexDouble[] q, int ldq, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int iwork, int[] ifail);
		//int Zhbgst(char vect, char uplo, int n, int[] ka, int[] kb, ComplexDouble[] ab, int ldab, ComplexDouble[] bb, int ldbb, ComplexDouble[] x, int ldx, ComplexDouble[] work, double[] rwork);
		//int Zhbgv(char jobz, char uplo, int n, int[] ka, int[] kb, ComplexDouble[] ab, int ldab, ComplexDouble[] bb, int ldbb, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork);
		//int Zhbgvx(char jobz, char range, char uplo, int n, int[] ka, int[] kb, ComplexDouble[] ab, int ldab, ComplexDouble[] bb, int ldbb, ComplexDouble[] q, int ldq, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int iwork, int[] ifail);
		//int Zhbtrd(char vect, char uplo, int n, int[] kd, ComplexDouble[] ab, int ldab, double[] d, double[] e, ComplexDouble[] q, int ldq, ComplexDouble[] work);
		//int Zhecon(char uplo, int n, ComplexDouble[] a, int lda, int[] ipiv, double[] anorm, double[] rcond, ComplexDouble[] work);
		//int Zheev(char jobz, char uplo, int n, ComplexDouble[] a, int lda, double[] w, ComplexDouble[] work, double[] rwork);
		//int Zheevd(char jobz, char uplo, int n, ComplexDouble[] a, int lda, double[] w, ComplexDouble[] work, double[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Zheevr(char jobz, char range, char uplo, int n, ComplexDouble[] a, int lda, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, ComplexDouble[] z, int ldz, int[] isuppz, ComplexDouble[] work, double[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Zheevx(char jobz, char range, char uplo, int n, ComplexDouble[] a, int lda, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int iwork, int[] ifail, int[] info);
		//int Zhegs2(int[] itype, char uplo, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb);
		//int Zhegst(int[] itype, char uplo, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb);
		//int Zhegv(int[] itype, char jobz, char uplo, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, double[] w, ComplexDouble[] work, double[] rwork);
		//int Zhegvd(int[] itype, char jobz, char uplo, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, double[] w, ComplexDouble[] work, double[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Zhegvx(int[] itype, char jobz, char range, char uplo, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int iwork, int[] ifail);
		//int Zherfs(char uplo, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] af, int ldaf, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zhesv(char uplo, int n, int nrhs, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] work);
		//int Zhesvx(char fact, char uplo, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] af, int ldaf, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] rcond, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zhetf2(char uplo, int n, ComplexDouble[] a, int lda, int[] ipiv);
		//int Zhetrd(char uplo, int n, ComplexDouble[] a, int lda, double[] d, double[] e, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zhetrf(char uplo, int n, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] work);
		//int Zhetri(char uplo, int n, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] work);
		//int Zhetrs(char uplo, int n, int nrhs, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] b, int ldb);
		//int Zhgeqz(char job, char compq, char compz, int n, int[] ilo, int[] ihi, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] alpha, ComplexDouble[] beta, ComplexDouble[] q, int ldq, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int[] info);
		//int Zhpcon(char uplo, int n, ComplexDouble[] ap, int[] ipiv, double[] anorm, double[] rcond, ComplexDouble[] work);
		//int Zhpev(char jobz, char uplo, int n, ComplexDouble[] ap, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork);
		//int Zhpevd(char jobz, char uplo, int n, ComplexDouble[] ap, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Zhpevx(char jobz, char range, char uplo, int n, ComplexDouble[] ap, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int iwork, int[] ifail);
		//int Zhpgst(int[] itype, char uplo, int n, ComplexDouble[] ap, ComplexDouble[] bp);
		//int Zhpgv(int[] itype, char jobz, char uplo, int n, ComplexDouble[] ap, ComplexDouble[] bp, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int[] info);
		//int Zhpgvd(int[] itype, char jobz, char uplo, int n, ComplexDouble[] ap, ComplexDouble[] bp, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int[] lrwork, int iwork, int[] liwork, int[] info);
		//int Zhpgvx(int[] itype, char jobz, char range, char uplo, int n, ComplexDouble[] ap, ComplexDouble[] bp, double[] vl, double[] vu, int[] il, int[] iu, double[] abstol, int m, double[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int iwork, int[] ifail);
		//int Zhprfs(char uplo, int n, int nrhs, ComplexDouble[] ap, ComplexDouble[] afp, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork, int[] info);
		//int Zhpsv(char uplo, int n, int nrhs, ComplexDouble[] ap, int[] ipiv, ComplexDouble[] b, int ldb);
		//int Zhpsvx(char fact, char uplo, int n, int nrhs, ComplexDouble[] ap, ComplexDouble[] afp, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] rcond, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zhptrd(char uplo, int n, ComplexDouble[] ap, double[] d, double[] e, ComplexDouble[] tau);
		//int Zhptrf(char uplo, int n, ComplexDouble[] ap, int[] ipiv);
		//int Zhptri(char uplo, int n, ComplexDouble[] ap, int[] ipiv, ComplexDouble[] work);
		//int Zhptrs(char uplo, int n, int nrhs, ComplexDouble[] ap, int[] ipiv, ComplexDouble[] b, int ldb);
		//int Zhsein(char side, char eigsrc, char initv, bool[] select, int n, ComplexDouble[] h, int ldh, ComplexDouble[] w, ComplexDouble[] vl, int ldvl, ComplexDouble[] vr, int ldvr, int[] mm, int m, ComplexDouble[] work, double[] rwork, int[] ifaill, int[] ifailr);
		//int Zhseqr(char job, char compz, int n, int[] ilo, int[] ihi, ComplexDouble[] h, int ldh, ComplexDouble[] w, ComplexDouble[] z, int ldz, ComplexDouble[] work);
		//int Zlabrd(int m, int n, int[] nb, ComplexDouble[] a, int lda, double[] d, double[] e, ComplexDouble[] tauq, ComplexDouble[] taup, ComplexDouble[] x, int ldx, ComplexDouble[] y, int ldy);
		//int Zlacgv(int n, ComplexDouble[] x, int[] incx);
		//int Zlacon(int n, ComplexDouble[] v, ComplexDouble[] x, double[] est, int[] kase);
		//int Zlacp2(char uplo, int m, int n, double[] a, int lda, ComplexDouble[] b, int ldb);
		//int Zlacpy(char uplo, int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb);
		//int Zlacrm(int m, int n, ComplexDouble[] a, int lda, double[] b, int ldb, ComplexDouble[] c, int ldc, double[] rwork);
		//int Zlacrt(int n, ComplexDouble[] cx, int[] incx, ComplexDouble[] cy, int[] incy, ComplexDouble[] c, ComplexDouble[] s);
		//int Zlaed0(int[] qsiz, int n, double[] d, double[] e, ComplexDouble[] q, int ldq, ComplexDouble[] qstore, int ldqs, double[] rwork, int iwork);
		//int Zlaed7(int n, int[] cutpnt, int[] qsiz, int[] tlvls, int[] curlvl, int[] curpbm, double[] d, ComplexDouble[] q, int ldq, double[] rho, int[] indxq, double[] qstore, int[] qptr, int[] prmptr, int[] perm, int[] givptr, int[] givcol, double[] givnum, ComplexDouble[] work, double[] rwork, int iwork);
		//int Zlaed8(int k, int n, int[] qsiz, ComplexDouble[] q, int ldq, double[] d, double[] rho, int[] cutpnt, double[] z, double[] dlamda, ComplexDouble[] q2, int ldq2, double[] w, int[] indxp, int[] indx, int[] indxq, int[] perm, int[] givptr, int[] givcol, double[] givnum);
		//int Zlaein(bool[] rightv, bool[] noinit, int n, ComplexDouble[] h, int ldh, ComplexDouble[] w, ComplexDouble[] v, ComplexDouble[] b, int ldb, double[] rwork, double[] eps3, double[] smlnum);
		//int Zlaesy(ComplexDouble[] a, ComplexDouble[] b, ComplexDouble[] c, ComplexDouble[] rt1, ComplexDouble[] rt2, ComplexDouble[] evscal, ComplexDouble[] cs1, ComplexDouble[] sn1);
		//int Zlaev2(ComplexDouble[] a, ComplexDouble[] b, ComplexDouble[] c, double[] rt1, double[] rt2, double[] cs1, ComplexDouble[] sn1);
		//int Zlags2(bool[] upper, double[] a1, ComplexDouble[] a2, double[] a3, double[] b1, ComplexDouble[] b2, double[] b3, double[] csu, ComplexDouble[] snu, double[] csv, ComplexDouble[] snv, double[] csq, ComplexDouble[] snq);
		//int Zlagtm(char trans, int n, int nrhs, double[] alpha, ComplexDouble[] dl, ComplexDouble[] d, ComplexDouble[] du, ComplexDouble[] x, int ldx, double[] beta, ComplexDouble[] b, int ldb);
		//int Zlahef(char uplo, int n, int[] nb, int[] kb, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] w, int ldw);
		//int Zlahqr(bool[] wantt, bool[] wantz, int n, int[] ilo, int[] ihi, ComplexDouble[] h, int ldh, ComplexDouble[] w, int[] iloz, int[] ihiz, ComplexDouble[] z, int ldz);
		//int Zlahrd(int n, int k, int[] nb, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] t, int ldt, ComplexDouble[] y, int ldy);
		//int Zlaic1(int[] job, int[] j, ComplexDouble[] x, double[] sest, ComplexDouble[] w, ComplexDouble[] gamma, double[] sestpr, ComplexDouble[] s, ComplexDouble[] c);
		//int Zlals0(int[] icompq, int[] nl, int[] nr, int[] sqre, int nrhs, ComplexDouble[] b, int ldb, ComplexDouble[] bx, int ldbx, int[] perm, int[] givptr, int[] givcol, int ldgcol, double[] givnum, int ldgnum, double[] poles, double[] difl, double[] difr, double[] z, int k, double[] c, double[] s, double[] rwork);
		//int Zlalsa(int[] icompq, int[] smlsiz, int n, int nrhs, ComplexDouble[] b, int ldb, ComplexDouble[] bx, int ldbx, double[] u, int ldu, double[] vt, int k, double[] difl, double[] difr, double[] z, double[] poles, int[] givptr, int[] givcol, int ldgcol, int[] perm, double[] givnum, double[] c, double[] s, double[] rwork, int iwork);
		//int Zlapll(int n, ComplexDouble[] x, int[] incx, ComplexDouble[] y, int[] incy, double[] ssmin);
		//int Zlapmt(bool[] forwrd, int m, int n, ComplexDouble[] x, int ldx, int k);
		//int Zlaqgb(int m, int n, int kl, int ku, ComplexDouble[] ab, int ldab, double[] r, double[] c, double[] rowcnd, double[] colcnd, double[] amax, char equed);
		//int Zlaqge(int m, int n, ComplexDouble[] a, int lda, double[] r, double[] c, double[] rowcnd, double[] colcnd, double[] amax, char equed);
		//int Zlaqhb(char uplo, int n, int[] kd, ComplexDouble[] ab, int ldab, double[] s, double[] scond, double[] amax, char equed);
		//int Zlaqhe(char uplo, int n, ComplexDouble[] a, int lda, double[] s, double[] scond, double[] amax, char equed);
		//int Zlaqhp(char uplo, int n, ComplexDouble[] ap, double[] s, double[] scond, double[] amax, char equed);
		//int Zlaqp2(int m, int n, int[] offset, ComplexDouble[] a, int lda, int[] jpvt, ComplexDouble[] tau, double[] vn1, double[] vn2, ComplexDouble[] work);
		//int Zlaqps(int m, int n, int[] offset, int[] nb, int[] kb, ComplexDouble[] a, int lda, int[] jpvt, ComplexDouble[] tau, double[] vn1, double[] vn2, ComplexDouble[] auxv, ComplexDouble[] f, int ldf);
		//int Zlaqsb(char uplo, int n, int[] kd, ComplexDouble[] ab, int ldab, double[] s, double[] scond, double[] amax, char equed);
		//int Zlaqsp(char uplo, int n, ComplexDouble[] ap, double[] s, double[] scond, double[] amax, char equed);
		//int Zlaqsy(char uplo, int n, ComplexDouble[] a, int lda, double[] s, double[] scond, double[] amax, char equed);
		//int Zlar1v(int n, int[] b1, int[] bn, double[] sigma, double[] d, double[] l, double[] ld, double[] lld, double[] gersch, ComplexDouble[] z, double[] ztz, double[] mingma, int[] r, int[] isuppz, double[] work);
		//int Zlar2v(int n, ComplexDouble[] x, ComplexDouble[] y, ComplexDouble[] z, int[] incx, double[] c, ComplexDouble[] s, int[] incc);
		//int Zlarcm(int m, int n, double[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] c, int ldc, double[] rwork);
		//int Zlarf(char side, int m, int n, ComplexDouble[] v, int[] incv, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zlarfb(char side, char trans, char direct, char storev, int m, int n, int k, ComplexDouble[] v, int[] ldv, ComplexDouble[] t, int ldt, ComplexDouble[] c, int ldc, ComplexDouble[] work, int ldwork);
		//int Zlarfg(int n, ComplexDouble[] alpha, ComplexDouble[] x, int[] incx, ComplexDouble[] tau);
		//int Zlarft(char direct, char storev, int n, int k, ComplexDouble[] v, int ldv, ComplexDouble[] tau, ComplexDouble[] t, int ldt);
		//int Zlarfx(char side, int m, int n, ComplexDouble[] v, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zlargv(int n, ComplexDouble[] x, int[] incx, ComplexDouble[] y, int[] incy, double[] c, int[] incc);
		//int Zlarnv(int[] idist, int[] iseed, int n, ComplexDouble[] x);
		//int Zlarrv(int n, double[] d, double[] l, int[] isplit, int m, double[] w, int[] iblock, double[] gersch, double[] tol, ComplexDouble[] z, int ldz, int[] isuppz, double[] work, int iwork);
		//int Zlartg(ComplexDouble[] f, ComplexDouble[] g, double[] cs, ComplexDouble[] sn, ComplexDouble[] r);
		//int Zlartv(int n, ComplexDouble[] x, int[] incx, ComplexDouble[] y, int[] incy, double[] c, ComplexDouble[] s, int[] incc);
		//int Zlarz(char side, int m, int n, int[] l, ComplexDouble[] v, int[] incv, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zlarzb(char side, char trans, char direct, char storev, int m, int n, int k, int[] l, ComplexDouble[] v, int ldv, ComplexDouble[] t, int ldt, ComplexDouble[] c, int ldc, ComplexDouble[] work, int ldwork);
		//int Zlarzt(char direct, char storev, int n, int k, ComplexDouble[] v, int ldv, ComplexDouble[] tau, ComplexDouble[] t, int ldt);
		//int Zlascl(char type, int kl, int ku, double[] cfrom, double[] cto, int m, int n, ComplexDouble[] a, int lda);
		//int Zlaset(char uplo, int m, int n, ComplexDouble[] alpha, ComplexDouble[] beta, ComplexDouble[] a, int lda);
		//int Zlasr(char side, char pivot, char direct, int m, int n, double[] c, double[] s, ComplexDouble[] a, int lda);
		//int Zlassq(int n, ComplexDouble[] x, int[] incx, double[] scale, double[] sumsq);
		//int Zlaswp(int n, ComplexDouble[] a, int lda, int[] k1, int[] k2, int[] ipiv, int[] incx);
		//int Zlasyf(char uplo, int n, int[] nb, int[] kb, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] w, int ldw);
		//int Zlatbs(char uplo, char trans, char diag, char normin, int n, int[] kd, ComplexDouble[] ab, int ldab, ComplexDouble[] x, double[] scale, double[] cnorm);
		//int Zlatdf(int[] ijob, int n, ComplexDouble[] z, int ldz, ComplexDouble[] rightSide, double[] rdsum, double[] rdscal, int[] ipiv, int[] jpiv);
		//int Zlatps(char uplo, char trans, char diag, char normin, int n, ComplexDouble[] ap, ComplexDouble[] x, double[] scale, double[] cnorm);
		//int Zlatrd(char uplo, int n, int[] nb, ComplexDouble[] a, int lda, double[] e, ComplexDouble[] tau, ComplexDouble[] w, int ldw);
		//int Zlatrs(char uplo, char trans, char diag, char normin, int n, ComplexDouble[] a, int lda, ComplexDouble[] x, double[] scale, double[] cnorm);
		//int Zlatrz(int m, int n, int[] l, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zlatzm(char side, int m, int n, ComplexDouble[] v, int[] incv, ComplexDouble[] tau, ComplexDouble[] c1, ComplexDouble[] c2, int ldc, ComplexDouble[] work);
		//int Zlauu2(char uplo, int n, ComplexDouble[] a, int lda);
		//int Zlauum(char uplo, int n, ComplexDouble[] a, int lda);
		//int Zpbcon(char uplo, int n, int[] kd, ComplexDouble[] ab, int ldab, double[] anorm, double[] rcond, ComplexDouble[] work, double[] rwork);
		//int Zpbequ(char uplo, int n, int[] kd, ComplexDouble[] ab, int ldab, double[] s, double[] scond, double[] amax);
		//int Zpbrfs(char uplo, int n, int[] kd, int nrhs, ComplexDouble[] ab, int ldab, ComplexDouble[] afb, int ldafb, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zpbstf(char uplo, int n, int[] kd, ComplexDouble[] ab, int ldab);
		//int Zpbsv(char uplo, int n, int[] kd, int nrhs, ComplexDouble[] ab, int ldab, ComplexDouble[] b, int ldb);
		//int Zpbsvx(char fact, char uplo, int n, int[] kd, int nrhs, ComplexDouble[] ab, int ldab, ComplexDouble[] afb, int ldafb, char equed, double[] s, ComplexDouble[] b, int[] ldb, ComplexDouble[] x, int ldx, double[] rcond, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zpbtf2(char uplo, int n, int[] kd, ComplexDouble[] ab, int ldab);
		//int Zpbtrf(char uplo, int n, int[] kd, ComplexDouble[] ab, int ldab);
		//int Zpbtrs(char uplo, int n, int[] kd, int nrhs, ComplexDouble[] ab, int ldab, ComplexDouble[] b, int ldb);
		//int Zpocon(char uplo, int n, ComplexDouble[] a, int lda, double[] anorm, double[] rcond, ComplexDouble[] work, double[] rwork);
		//int Zpoequ(int n, ComplexDouble[] a, int lda, double[] s, double[] scond, double[] amax);
		//int Zporfs(char uplo, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] af, int ldaf, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zposv(char uplo, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb);
		//int Zposvx(char fact, char uplo, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] af, int ldaf, char equed, double[] s, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] rcond, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork, int[] info);
		//int Zpotf2(char uplo, int n, ComplexDouble[] a, int lda);
		//int Zppcon(char uplo, int n, ComplexDouble[] ap, double[] anorm, double[] rcond, ComplexDouble[] work, double[] rwork);
		//int Zppequ(char uplo, int n, ComplexDouble[] ap, double[] s, double[] scond, double[] amax);
		//int Zpprfs(char uplo, int n, int nrhs, ComplexDouble[] ap, ComplexDouble[] afp, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zppsv(char uplo, int n, int nrhs, ComplexDouble[] ap, ComplexDouble[] b, int ldb);
		//int Zppsvx(char fact, char uplo, int n, int nrhs, ComplexDouble[] ap, ComplexDouble[] afp, char equed, double[] s, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] rcond, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zpptrf(char uplo, int n, ComplexDouble[] ap);
		//int Zpptri(char uplo, int n, ComplexDouble[] ap);
		//int Zpptrs(char uplo, int n, int nrhs, ComplexDouble[] ap, ComplexDouble[] b, int ldb);
		//int Zptcon(int n, double[] d, ComplexDouble[] e, double[] anorm, double[] rcond, double[] rwork, int[] info);
		//int Zptrfs(char uplo, int n, int nrhs, double[] d, ComplexDouble[] e, double[] df, ComplexDouble[] ef, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zptsv(int n, int nrhs, double[] d, ComplexDouble[] e, ComplexDouble[] b, int ldb);
		//int Zptsvx(char fact, int n, int nrhs, double[] d, ComplexDouble[] e, double[] df, ComplexDouble[] ef, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] rcond, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zpttrf(int n, double[] d, ComplexDouble[] e);
		//int Zpttrs(char uplo, int n, int nrhs, double[] d, ComplexDouble[] e, ComplexDouble[] b, int ldb);
		//int Zptts2(int[] iuplo, int n, int nrhs, double[] d, ComplexDouble[] e, ComplexDouble[] b, int ldb);
		//int Zrot(int n, ComplexDouble[] cx, int[] incx, ComplexDouble[] cy, int[] incy, double[] c, ComplexDouble[] s);
		//int Zspcon(char uplo, int n, ComplexDouble[] ap, int[] ipiv, double[] anorm, double[] rcond, ComplexDouble[] work);
		//int Zspmv(char uplo, int n, ComplexDouble[] alpha, ComplexDouble[] ap, ComplexDouble[] x, int[] incx, ComplexDouble[] beta, ComplexDouble[] y, int[] incy);
		//int Zspr(char uplo, int n, ComplexDouble[] alpha, ComplexDouble[] x, int[] incx, ComplexDouble[] ap);
		//int Zsprfs(char uplo, int n, int nrhs, ComplexDouble[] ap, ComplexDouble[] afp, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork, int[] info);
		//int Zspsv(char uplo, int n, int nrhs, ComplexDouble[] ap, int[] ipiv, ComplexDouble[] b, int ldb);
		//int Zspsvx(char fact, char uplo, int n, int nrhs, ComplexDouble[] ap, ComplexDouble[] afp, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] rcond, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zsptrf(char uplo, int n, ComplexDouble[] ap, int[] ipiv);
		//int Zsptri(char uplo, int n, ComplexDouble[] ap, int[] ipiv, ComplexDouble[] work);
		//int Zsptrs(char uplo, int n, int nrhs, ComplexDouble[] ap, int[] ipiv, ComplexDouble[] b, int ldb);
		//int Zstedc(char compz, int n, double[] d, double[] e, ComplexDouble[] z, int ldz, ComplexDouble[] work, double[] rwork, int[] lrwork, int iwork, int[] liwork);
		//int Zstein(int n, double[] d, double[] e, int m, double[] w, int[] iblock, int[] isplit, ComplexDouble[] z, int ldz, double[] work, int iwork, int[] ifail);
		//int Zsteqr(char compz, int n, double[] d, double[] e, ComplexDouble[] z, int ldz, double[] work);
		//int Zsycon(char uplo, int n, ComplexDouble[] a, int lda, int[] ipiv, double[] anorm, double[] rcond, ComplexDouble[] work);
		//int Zsymv(char uplo, int n, ComplexDouble[] alpha, ComplexDouble[] a, int lda, ComplexDouble[] x, int[] incx, ComplexDouble[] beta, ComplexDouble[] y, int[] incy);
		//int Zsyr(char uplo, int n, ComplexDouble[] alpha, ComplexDouble[] x, int[] incx, ComplexDouble[] a, int lda);
		//int Zsyrfs(char uplo, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] af, int ldaf, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zsysv(char uplo, int n, int nrhs, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] work);
		//int Zsysvx(char fact, char uplo, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] af, int ldaf, int[] ipiv, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] rcond, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Zsytf2(char uplo, int n, ComplexDouble[] a, int lda, int[] ipiv);
		//int Zsytrf(char uplo, int n, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] work);
		//int Zsytri(char uplo, int n, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] work);
		//int Zsytrs(char uplo, int n, int nrhs, ComplexDouble[] a, int lda, int[] ipiv, ComplexDouble[] b, int ldb);
		//int Ztbcon(char norm, char uplo, char diag, int n, int[] kd, ComplexDouble[] ab, int ldab, double[] rcond, ComplexDouble[] work, double[] rwork);
		//int Ztbrfs(char uplo, char trans, char diag, int n, int[] kd, int nrhs, ComplexDouble[] ab, int ldab, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Ztbtrs(char uplo, char trans, char diag, int n, int[] kd, int nrhs, ComplexDouble[] ab, int ldab, ComplexDouble[] b, int ldb);
		//int Ztgevc(char side, char howmny, bool[] select, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int[] ldb, ComplexDouble[] vl, int ldvl, ComplexDouble[] vr, int ldvr, int[] mm, int m, ComplexDouble[] work, double[] rwork);
		//int Ztgex2(bool[] wantq, bool[] wantz, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] q, int ldq, ComplexDouble[] z, int ldz, int[] j1);
		//int Ztgexc(bool[] wantq, bool[] wantz, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] q, int ldq, ComplexDouble[] z, int ldz, int[] ifst, int[] ilst);
		//int Ztgsen(int[] ijob, bool[] wantq, bool[] wantz, bool[] select, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] alpha, ComplexDouble[] beta, ComplexDouble[] q, int ldq, ComplexDouble[] z, int ldz, int m, double[] pl, double[] pr, double[] dif, ComplexDouble[] work, int iwork, int[] liwork);
		//int Ztgsja(char jobu, char jobv, char jobq, int m, int[] p, int n, int k, int[] l, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, double[] tola, double[] tolb, double[] alpha, double[] beta, ComplexDouble[] u, int ldu, ComplexDouble[] v, int ldv, ComplexDouble[] q, int ldq, ComplexDouble[] work, int[] ncycle);
		//int Ztgsna(char job, char howmny, bool[] select, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int[] ldb, ComplexDouble[] vl, int ldvl, ComplexDouble[] vr, int ldvr, double[] s, double[] dif, int[] mm, int m, ComplexDouble[] work, int iwork);
		//int Ztgsy2(char trans, int[] ijob, int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] c, int ldc, ComplexDouble[] d, int ldd, ComplexDouble[] e, int lde, ComplexDouble[] f, int ldf, double[] scale, double[] rdsum, double[] rdscal, int[] info);
		//int Ztgsyl(char trans, int[] ijob, int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] c, int ldc, ComplexDouble[] d, int ldd, ComplexDouble[] e, int lde, ComplexDouble[] f, int ldf, double[] scale, double[] dif, ComplexDouble[] work, int iwork);
		//int Ztpcon(char norm, char uplo, char diag, int n, ComplexDouble[] ap, double[] rcond, ComplexDouble[] work, double[] rwork);
		//int Ztprfs(char uplo, char trans, char diag, int n, int nrhs, ComplexDouble[] ap, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork);
		//int Ztptri(char uplo, char diag, int n, ComplexDouble[] ap);
		//int Ztptrs(char uplo, char trans, char diag, int n, int nrhs, ComplexDouble[] ap, ComplexDouble[] b, int ldb);
		//int Ztrcon(char norm, char uplo, char diag, int n, ComplexDouble[] a, int lda, double[] rcond, ComplexDouble[] work, double[] rwork);
		//int Ztrevc(char side, char howmny, bool[] select, int n, ComplexDouble[] t, int ldt, ComplexDouble[] vl, int ldvl, ComplexDouble[] vr, int ldvr, int[] mm, int m, ComplexDouble[] work, double[] rwork);
		//int Ztrexc(char compq, int n, ComplexDouble[] t, int ldt, ComplexDouble[] q, int ldq, int[] ifst, int[] ilst);
		//int Ztrrfs(char uplo, char trans, char diag, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] x, int ldx, double[] ferr, double[] berr, ComplexDouble[] work, double[] rwork, int[] info);
		//int Ztrsen(char job, char compq, bool[] select, int n, ComplexDouble[] t, int ldt, ComplexDouble[] q, int ldq, ComplexDouble[] w, int m, double[] s, double[] sep, ComplexDouble[] work);
		//int Ztrsna(char job, char howmny, bool[] select, int n, ComplexDouble[] t, int ldt, ComplexDouble[] vl, int ldvl, ComplexDouble[] vr, int ldvr, double[] s, double[] sep, int[] mm, int m, ComplexDouble[] work, int ldwork, double[] rwork);
		//int Ztrsyl(char trana, char tranb, int[] isgn, int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble[] c, int ldc, double[] scale);
		//int Ztrti2(char uplo, char diag, int n, ComplexDouble[] a, int lda);
		//int Ztrtri(char uplo, char diag, int n, ComplexDouble[] a, int lda);
		//int Ztrtrs(char uplo, char trans, char diag, int n, int nrhs, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb);
		//int Ztzrqf(int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau);
		//int Ztzrzf(int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zung2l(int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zung2r(int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zungbr(char vect, int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zunghr(int n, int[] ilo, int[] ihi, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zungl2(int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zunglq(int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zungql(int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zungr2(int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zungrq(int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zungtr(char uplo, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] work);
		//int Zunm2l(char side, char trans, int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zunm2r(char side, char trans, int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zunmbr(char vect, char side, char trans, int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zunmhr(char side, char trans, int m, int n, int[] ilo, int[] ihi, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zunml2(char side, char trans, int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zunmlq(char side, char trans, int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zunmql(char side, char trans, int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zunmr2(char side, char trans, int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zunmr3(char side, char trans, int m, int n, int k, int[] l, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work, int[] info);
		//int Zunmrq(char side, char trans, int m, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zunmrz(char side, char trans, int m, int n, int k, int[] l, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zunmtr(char side, char uplo, char trans, int m, int n, ComplexDouble[] a, int lda, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int Zupgtr(char uplo, int n, ComplexDouble[] ap, ComplexDouble[] tau, ComplexDouble[] q, int ldq, ComplexDouble[] work);
		//int Zupmtr(char side, char uplo, char trans, int m, int n, ComplexDouble[] ap, ComplexDouble[] tau, ComplexDouble[] c, int ldc, ComplexDouble[] work);
		//int xerbla(char srname);
		//int icmax1(int n, ComplexFloat[] cx, int[] incx);
		//int ieeeck(int[] ispec, float[] zero, float[] one);
		//int izmax1(int n, ComplexDouble[] cx, int[] incx);

	}
}